aria-code 0.52.0__py3-none-any.whl

aria_code/agents/financial/strategist.py

@@ -0,0 +1,121 @@
+"""
+agents/financial/strategist.py — Quant Strategist Client Agent
+=============================================================
+Bridges client-side agent invocation with the cloud QuantStrategistAgent
+and RiskComplianceAgent. Produces formal SignalRuleTree specifications.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class StrategistAgent(BaseAgent):
+    name = "strategist"
+    description = "量化策略师智能体 — 负责设计策略规则树、因子组合与进出场逻辑"
+
+    def __init__(
+        self,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_thought: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict], None]] = None,
+        on_tool_end: Optional[Callable[[str, Any], None]] = None,
+        lang: str = "zh",
+    ) -> None:
+        super().__init__(
+            llm_provider=llm_provider,
+            data_router=data_router,
+            on_token=on_token,
+            on_thought=on_thought,
+            on_tool_start=on_tool_start,
+            on_tool_end=on_tool_end,
+            lang=lang,
+        )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        Design standardized quantitative strategy rule tree.
+        """
+        style = data.get("style", "momentum")
+        goal = data.get("goal", f"Maximize risk-adjusted returns on {symbol}")
+        params = data.get("params", {})
+
+        # Try to import from Arthera packages quant engine
+        try:
+            from packages.quant_engine.agent_runtime.quant_strategist import QuantStrategistAgent
+            from packages.quant_engine.risk.risk_compliance_agent import RiskComplianceAgent
+
+            cloud_strategist = QuantStrategistAgent()
+            rule_tree = await cloud_strategist.design_strategy(
+                symbol=symbol,
+                goal=goal,
+                style=style,
+                timeframe="1d",
+                params=params,
+            )
+
+            # Pass through Risk & Compliance audit
+            risk_agent = RiskComplianceAgent()
+            audit = risk_agent.audit_and_harden(rule_tree)
+            rule_dict = rule_tree.to_dict()
+
+        except Exception as exc:
+            logger.warning(f"Could not import Arthera cloud quant engine, using internal fallback: {exc}")
+            rule_dict = {
+                "strategy_id": f"strat_{symbol.lower()}_fallback",
+                "strategy_name": f"{symbol} Dual Moving Average",
+                "symbol": symbol,
+                "factors": [
+                    {"name": "SMA_Fast", "params": {"period": 10}},
+                    {"name": "SMA_Slow", "params": {"period": 30}},
+                ],
+                "entry_conditions": [
+                    {"indicator": "SMA_Fast", "operator": "cross_above", "threshold": "SMA_Slow", "action": "BUY"}
+                ],
+                "exit_conditions": [
+                    {"trigger_type": "stop_loss", "params": {"stop_loss_pct": 7.0}, "action": "SELL"}
+                ],
+                "risk_constraints": {
+                    "max_drawdown_limit_pct": 18.0,
+                    "max_position_size_pct": 25.0,
+                    "stop_loss_pct": 7.0,
+                    "slippage_pct": 0.05,
+                    "commission_pct": 0.05,
+                },
+            }
+
+        factors_summary = ", ".join(f.get("name", "") for f in rule_dict.get("factors", []))
+        summary = (
+            f"### 📈 量化策略规则树规划完成: {rule_dict.get('strategy_name', symbol)}\n\n"
+            f"• **标的资产**: {symbol}\n"
+            f"• **选取因子**: {factors_summary}\n"
+            f"• **入场条件**: {rule_dict.get('entry_conditions', [{}])[0].get('description', '金叉信号入场')}\n"
+            f"• **风控约束**: 止损 {rule_dict.get('risk_constraints', {}).get('stop_loss_pct', 7.0)}%, "
+            f"最大回撤控制 {rule_dict.get('risk_constraints', {}).get('max_drawdown_limit_pct', 20.0)}%, "
+            f"滑点摩擦 {rule_dict.get('risk_constraints', {}).get('slippage_pct', 0.05)}%\n"
+            f"• **后续流转**: 规则已下发至 Coder Agent 进行自包含工程编码"
+        )
+
+        return AgentResult(
+            agent=self.name,
+            symbol=symbol,
+            analysis=summary,
+            confidence=0.90,
+            signal="BUY",
+            key_points=[
+                f"Generated SignalRuleTree for {symbol}",
+                f"Factors: {factors_summary}",
+                "Injected risk & friction constraints",
+            ],
+            data_used={
+                "rule_tree": rule_dict,
+                "symbol": symbol,
+            },
+        )

aria_code/agents/financial/stripe_revenue.py

@@ -0,0 +1,127 @@
+"""
+agents/financial/stripe_revenue.py — Stripe Business Revenue & Churn Analysis Agent
+===================================================================================
+Analyzes user-connected Stripe financial datasets:
+1. Gross Payment Volume (GPV), Stripe Fees & Realized Net Revenue
+2. MRR/ARR Velocity, Subscription Cohorts, and ARPU
+3. Involuntary Churn & Failed Payment Dunning Recovery Analysis
+4. Customer Lifetime Value (LTV) and Net Revenue Retention (NRR)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class StripeRevenueAgent(BaseAgent):
+    name = "stripe_revenue"
+    description = "Stripe 商业营收与流失率分析智能体 — 负责实时 GPV、MRR/ARR、退款率与未支付催收诊断"
+
+    def __init__(
+        self,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_thought: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict], None]] = None,
+        on_tool_end: Optional[Callable[[str, Any], None]] = None,
+        lang: str = "zh",
+    ) -> None:
+        super().__init__(
+            llm_provider=llm_provider,
+            data_router=data_router,
+            on_token=on_token,
+            on_thought=on_thought,
+            on_tool_start=on_tool_start,
+            on_tool_end=on_tool_end,
+            lang=lang,
+        )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        Analyze connected Stripe business data.
+        """
+        business_name = symbol or data.get("business_name", "Enterprise SaaS")
+        charges = data.get("charges", data.get("transactions", []))
+        subscriptions = data.get("subscriptions", [])
+
+        from aria_code.packages.aria_tools.financial._paths import ensure_arthera_root
+        ensure_arthera_root()
+
+        # Try to use Arthera StripeAnalyticsService
+        try:
+            from packages.quant_engine.services.stripe_analytics_service import StripeAnalyticsService
+            service = StripeAnalyticsService()
+            summary = service.analyze_stripe_data(charges, subscriptions)
+            summary_dict = summary.to_dict()
+        except Exception as exc:
+            logger.debug(f"Arthera stripe analytics service not imported, using local fallback: {exc}")
+            summary_dict = self._local_analyze(charges, subscriptions)
+
+        gpv = summary_dict.get("gross_payment_volume_usd", 0.0)
+        net_rev = summary_dict.get("net_revenue_usd", 0.0)
+        mrr = summary_dict.get("mrr_usd", 0.0)
+        arr = summary_dict.get("arr_usd", 0.0)
+        churn = summary_dict.get("monthly_churn_rate_pct", 0.0)
+        nrr = summary_dict.get("net_revenue_retention_pct", 100.0)
+        failed_amt = summary_dict.get("failed_payment_amount_usd", 0.0)
+        recoverable = summary_dict.get("recoverable_dunning_amount_usd", 0.0)
+        recs = summary_dict.get("revenue_growth_recommendations", [])
+        plans = summary_dict.get("plan_breakdown", [])
+
+        plan_rows = [f"| {p.get('plan_name')} | {p.get('subscribers')} | ¥{p.get('mrr_usd', 0):,.2f} |" for p in plans]
+        plan_table = "\n".join(plan_rows) if plan_rows else "| 主营订阅方案 | 活跃 | 稳定增长 |"
+
+        analysis_text = (
+            f"### 💳 Stripe 商业营收与订阅增长诊断报告: {business_name}\n\n"
+            f"• **总交易流水 (GPV)**: `¥{gpv:,.2f}` | **净营收**: `¥{net_rev:,.2f}`\n"
+            f"• **订阅年化营收 (ARR)**: `¥{arr:,.2f}` (月度 MRR: `¥{mrr:,.2f}`)\n"
+            f"• **月度客户流失率 (Churn)**: `{churn:.1f}%` | **净收益留存率 (NRR)**: `{nrr:.1f}%`\n"
+            f"• **未支付/失败交易损失**: `¥{failed_amt:,.2f}` (智能催收预计可挽回: `¥{recoverable:,.2f}`)\n\n"
+            f"| 订阅层级 (Plan) | 订阅人数 | 贡献 MRR |\n"
+            f"| :--- | :--- | :--- |\n"
+            f"{plan_table}\n\n"
+            f"**💡 营收增长与催收对策**:\n"
+            + ("\n".join(f"- {r}" for r in recs) if recs else "- 交易指标处于健康区间。")
+        )
+
+        signal = "GOOD" if churn < 5.0 and failed_amt < 500 else ("CONCERN" if churn < 10.0 else "SEVERE")
+
+        return AgentResult(
+            agent=self.name,
+            symbol=business_name,
+            analysis=analysis_text,
+            confidence=0.95,
+            signal=signal,
+            key_points=[
+                f"Gross Payment Volume: ¥{gpv:,.2f}",
+                f"Monthly Recurring Revenue: ¥{mrr:,.2f} (ARR: ¥{arr:,.2f})",
+                f"Monthly Churn Rate: {churn:.1f}% (NRR: {nrr:.1f}%)",
+                f"Failed Payment Recovery Potential: ¥{recoverable:,.2f}",
+            ],
+            data_used=summary_dict,
+            provenance=["stripe-charges-stream", "stripe-subscriptions-matrix", "dunning-recovery-model"],
+        )
+
+    def _local_analyze(self, charges: List[Dict[str, Any]], subscriptions: List[Dict[str, Any]]) -> Dict[str, Any]:
+        gpv = sum(float(c.get("amount_usd", c.get("amount", 0.0))) for c in charges if c.get("status") == "succeeded")
+        mrr = sum(float(s.get("mrr_usd", s.get("mrr", 0.0))) for s in subscriptions if s.get("status") == "active")
+        failed = sum(float(c.get("amount_usd", c.get("amount", 0.0))) for c in charges if c.get("status") == "failed")
+        return {
+            "gross_payment_volume_usd": gpv,
+            "net_revenue_usd": gpv * 0.95,
+            "mrr_usd": mrr,
+            "arr_usd": mrr * 12.0,
+            "monthly_churn_rate_pct": 3.5,
+            "net_revenue_retention_pct": 105.0,
+            "failed_payment_amount_usd": failed,
+            "recoverable_dunning_amount_usd": round(failed * 0.55, 2),
+            "plan_breakdown": [],
+            "revenue_growth_recommendations": ["本地离线模式：已完成基础指标提取"],
+        }

aria_code/agents/financial/synthesis.py

@@ -0,0 +1,274 @@
+"""
+agents/financial/synthesis.py — 综合汇总 Agent
+===============================================
+汇总所有 agent 结果，输出可操作的投资建议。
+加权规则：置信度平方作为权重，高置信度信号影响力更大。
+"""
+from __future__ import annotations
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+# 每个 agent 的基础重要性权重（反映信息价值，可在 .ariarc 中覆盖）
+_AGENT_WEIGHTS: Dict[str, float] = {
+    "technical":   1.2,   # 短期动量信息量最高
+    "fundamental": 1.1,   # 价值锚
+    "risk":        1.0,
+    "macro":       0.9,   # 宏观慢变量，不应过度主导短期判断
+    "news":        1.0,
+    "catalyst":    1.1,   # 催化剂改变时机，提高权重
+    "earnings":    1.1,
+    "sector":      0.8,
+    "debate":      0.5,   # 调解结果已融入其他 agent，避免重复计入
+}
+
+_SIGNAL_SCORE: Dict[str, float] = {
+    "STRONG_BUY":  2.0,
+    "BUY":         1.0,
+    "HOLD":        0.0,
+    "SELL":        -1.0,
+    "STRONG_SELL": -2.0,
+}
+
+
+class SynthesisAgent(BaseAgent):
+    name        = "synthesis"
+    description = "综合汇总：整合多 Agent 结论，输出操作建议（置信度加权投票）"
+
+    _SYSTEM = (
+        "You are the chief investment strategist. Synthesize analyses from "
+        "macro, fundamental, technical, and risk agents into a clear, "
+        "actionable investment recommendation. Be concise and direct. "
+        "End with: FINAL: BUY / HOLD / SELL (with target price and stop loss IF real data is available)."
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        agent_results: List[Dict] = data.get("agent_results", [])
+        consensus_signal = str(data.get("consensus_signal") or "HOLD").upper()
+        consensus_conf = data.get("consensus_confidence")
+        consensus_conf_num = (
+            _safe_float(consensus_conf)
+            if consensus_conf is not None else _calc_weighted_confidence(agent_results)
+        )
+
+        # Check if any agent had real price data
+        _quote = data.get("quote", {})
+        _snapshot = data.get("market_snapshot", {}) or {}
+        _price = _snapshot.get("price") or (_quote.get("price", 0) if _quote else 0)
+        _data_available = bool(_safe_float(_price))
+        _market_block = data.get("market_data_block") or _format_market_block(data)
+        _target = _snapshot.get("analyst_target")
+        _stop = _risk_stop(_snapshot, _snapshot.get("currency") or "USD")
+
+        summary_parts = []
+        for r in agent_results:
+            if not r.get("error"):
+                agent_name = r["agent"].upper()
+                signal     = r.get("signal", "HOLD")
+                conf       = r.get("confidence", 0.5)
+                points     = r.get("key_points", [])
+                pts_str    = "; ".join(points[:2]) if points else r.get("analysis", "")[:80]
+                summary_parts.append(
+                    f"[{agent_name}] Signal={signal} ({conf:.0%}): {pts_str}"
+                )
+
+        summary = "\n".join(summary_parts) if summary_parts else "No agent data"
+
+        if _data_available:
+            _price_instruction = (
+                "3. Entry strategy using ONLY the supplied current price, MA20/MA60, RSI, MACD and analyst_target.\n"
+                "4. Target/stop rules: use analyst_target only if supplied; otherwise write Target: N/A (analyst target missing). "
+                "Use stated support first; use MA60 only when price is still above it. If price is already below MA60, call MA60 a recovery level, not a stop. Do not invent prices.\n"
+                f"FINAL: {consensus_signal} | Target: "
+                f"{'$' + str(_target) if _safe_float(_target) else 'N/A (analyst target missing)'} | "
+                f"Stop: {_stop}"
+            )
+        else:
+            _price_instruction = (
+                "3. Entry strategy qualitative only because current price is missing.\n"
+                "4. Do not give target or stop prices.\n"
+                f"FINAL: {consensus_signal} | Target: N/A (price missing) | Stop: N/A"
+            )
+
+        prompt = (
+            f"Symbol: {symbol}\n"
+            f"Consensus signal: {consensus_signal}\n"
+            f"Consensus confidence: {consensus_conf_num:.0%}\n"
+            f"Real price data available: {'YES — price=' + str(_price) if _data_available else 'NO — do not invent prices'}\n"
+            f"Verified market data:\n{_market_block}\n\n"
+            f"Agent Analyses:\n{summary}\n\n"
+            "Provide final recommendation:\n"
+            "1. Overall investment thesis (2-3 concise sentences, grounded in verified market data)\n"
+            "2. Key risks to monitor; separate structural risks from missing real-time risk data\n"
+            + _price_instruction
+        )
+
+        analysis  = await self._call_llm(self._SYSTEM, prompt, max_tokens=600, quote=_quote)
+        if not analysis:
+            analysis = _template_synthesis(symbol, agent_results, data)
+        elif _data_available:
+            analysis = (
+                analysis
+                .replace("N/A (no real data)", "N/A (analyst target missing)")
+                .replace("no real data", "analyst target missing")
+                .replace("信心 ≤40%", f"置信度 {consensus_conf_num:.0%}")
+            )
+
+        signal     = consensus_signal or _extract_final_signal(analysis)
+        confidence = consensus_conf_num
+        key_points = _extract_key_points(analysis)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis, confidence=confidence,
+            signal=signal, key_points=key_points,
+        )
+
+
+def _extract_final_signal(text: str) -> str:
+    import re
+    m = re.search(r"FINAL[:\s]+([A-Z_]+)", text.upper())
+    if m:
+        raw = m.group(1)
+        if "STRONG_BUY" in raw:  return "STRONG_BUY"
+        if "BUY" in raw:         return "BUY"
+        if "STRONG_SELL" in raw: return "STRONG_SELL"
+        if "SELL" in raw:        return "SELL"
+    return "HOLD"
+
+
+def _calc_weighted_confidence(results: List[Dict]) -> float:
+    """
+    Confidence = weighted average where weight = agent_base_weight × confidence².
+    High-confidence agents dominate; low-confidence agents contribute minimally.
+    """
+    valid = [r for r in results if not r.get("error")]
+    if not valid:
+        return 0.5
+    total_w, weighted_sum = 0.0, 0.0
+    for r in valid:
+        conf      = max(0.0, min(1.0, float(r.get("confidence", 0.5))))
+        base_w    = _AGENT_WEIGHTS.get(r.get("agent", ""), 1.0)
+        w         = base_w * (conf ** 2)          # confidence² amplifies strong signals
+        weighted_sum += conf * w
+        total_w      += w
+    return round(weighted_sum / total_w, 2) if total_w else 0.5
+
+
+def _calc_weighted_signal_score(results: List[Dict]) -> float:
+    """Weighted signal score used by the template fallback."""
+    valid = [r for r in results if not r.get("error")]
+    if not valid:
+        return 0.0
+    total_w, score_sum = 0.0, 0.0
+    for r in valid:
+        conf   = max(0.0, min(1.0, float(r.get("confidence", 0.5))))
+        base_w = _AGENT_WEIGHTS.get(r.get("agent", ""), 1.0)
+        w      = base_w * (conf ** 2)
+        score  = _SIGNAL_SCORE.get(r.get("signal", "HOLD"), 0.0)
+        score_sum += score * w
+        total_w   += w
+    return score_sum / total_w if total_w else 0.0
+
+
+def _extract_key_points(text: str) -> List[str]:
+    points = []
+    for line in text.split("\n"):
+        line = line.strip()
+        if line.startswith(("1.", "2.", "3.", "4.", "•", "-", "·")) and len(line) > 8:
+            points.append(line.lstrip("1234567890.-•· "))
+    return points[:4]
+
+
+def _safe_float(value: Any) -> float | None:
+    try:
+        if value in (None, ""):
+            return None
+        return float(value)
+    except Exception:
+        return None
+
+
+def _fmt_price(value: Any, currency: str = "USD") -> str:
+    number = _safe_float(value)
+    return f"{currency} {number:.2f}" if number is not None else "N/A"
+
+
+def _first_level(value: Any) -> float | None:
+    if value in (None, "", [], {}):
+        return None
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            level = _first_level(item)
+            if level is not None:
+                return level
+        return None
+    if isinstance(value, dict):
+        for key in ("price", "level", "value"):
+            level = _safe_float(value.get(key))
+            if level is not None:
+                return level
+        return None
+    text = str(value).replace("USD", "").replace("$", "").split(",")[0].strip()
+    return _safe_float(text)
+
+
+def _risk_stop(snapshot: Dict[str, Any], currency: str = "USD") -> str:
+    support = _first_level(snapshot.get("support") or snapshot.get("supports"))
+    if support is not None:
+        return f"below support {_fmt_price(support, currency)}"
+
+    ma60 = _safe_float(snapshot.get("ma60"))
+    price = _safe_float(snapshot.get("price"))
+    if ma60 is None:
+        return "N/A (technical stop missing)"
+    if price is not None and price < ma60:
+        return f"N/A (already below MA60; recovery level {_fmt_price(ma60, currency)})"
+    return f"below MA60 {_fmt_price(ma60, currency)}"
+
+
+def _format_market_block(data: Dict[str, Any]) -> str:
+    snapshot = data.get("market_snapshot", {}) or {}
+    quote = data.get("quote", {}) or {}
+    fundamentals = data.get("fundamentals", {}) or {}
+    technical = data.get("technical", {}) or {}
+    quality = data.get("data_quality", {}) or {}
+    return "\n".join([
+        f"data_status={quality.get('status') or snapshot.get('status') or 'unknown'}",
+        f"providers={', '.join(snapshot.get('provider_chain') or quality.get('providers') or []) or 'unknown'}",
+        f"missing={', '.join(snapshot.get('missing_fields') or quality.get('missing_fields') or []) or 'none'}",
+        f"price={snapshot.get('price') or quote.get('price')}",
+        f"market_cap={snapshot.get('market_cap') or quote.get('market_cap') or fundamentals.get('market_cap')}",
+        f"pe={snapshot.get('pe_ratio') or fundamentals.get('pe_ratio') or fundamentals.get('pe_ttm')}",
+        f"analyst_target={snapshot.get('analyst_target') or fundamentals.get('analyst_target')}",
+        f"rsi={snapshot.get('rsi') or technical.get('rsi')}",
+        f"macd_hist={snapshot.get('macd_hist') or technical.get('macd_hist')}",
+        f"ma20={snapshot.get('ma20') or technical.get('ma20')}",
+        f"ma60={snapshot.get('ma60') or technical.get('ma60')}",
+    ])
+
+
+def _template_synthesis(symbol: str, results: List[Dict], data: Dict[str, Any] | None = None) -> str:
+    data = data or {}
+    avg_s  = _calc_weighted_signal_score(results)
+    final  = str(data.get("consensus_signal") or ("BUY" if avg_s > 0.4 else ("SELL" if avg_s < -0.4 else "HOLD"))).upper()
+    conf   = float(data.get("consensus_confidence") or _calc_weighted_confidence(results))
+    snapshot = data.get("market_snapshot", {}) or {}
+    currency = snapshot.get("currency") or "USD"
+    price = _fmt_price(snapshot.get("price"), currency)
+    target = _fmt_price(snapshot.get("analyst_target"), currency) if _safe_float(snapshot.get("analyst_target")) else "N/A (analyst target missing)"
+    stop = _risk_stop(snapshot, currency)
+    providers = ", ".join(snapshot.get("provider_chain") or []) or "unknown"
+    missing = ", ".join(snapshot.get("missing_fields") or []) or "none"
+
+    agent_lines = "\n".join(
+        f"  • {r['agent'].upper()} ({r.get('confidence', 0.5):.0%}): "
+        f"{r.get('signal','?')} — " + "; ".join(r.get("key_points", [])[:1])
+        for r in results if not r.get("error")
+    )
+    return (
+        f"{symbol} 综合分析（真实数据加权汇总）\n"
+        f"当前价: {price}  数据源: {providers}  缺失: {missing}\n"
+        f"{agent_lines}\n\n"
+        f"加权信号得分: {avg_s:+.2f}  综合置信度: {conf:.0%}\n"
+        f"FINAL: {final} | Target: {target} | Stop: {stop}"
+    )