aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/deep/pipeline.py

@@ -0,0 +1,164 @@
+"""Deep analysis orchestrator — ties P0–P3 into one layered pass.
+
+    team (parallel agents) ─▶ group by theme (P1a) ─▶ deepen gaps (P0)
+        ─▶ quant fusion (P2) ─▶ vote ─▶ calibrate (P2) ─▶ critic (P1b)
+        ─▶ synthesis ─▶ tiered result (P3)
+
+``analyze()`` is the deterministic core (assembles a DeepAnalysisResult from given
+agent results); it needs no LLM or network and is fully unit-tested. ``run()`` is
+the async convenience that first runs the AgentTeam, then calls ``analyze()``.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Callable, Dict, List, Optional
+
+from ..base import AgentResult
+from .critic import critique, soften_signal
+from .deepen import deepen
+from .models import DeepAnalysisResult
+from .quant_fusion import CalibrationStore, calibrate_confidence, gather_quant_evidence
+from .themes import group_by_theme
+
+
+def _vote_all(results: List[AgentResult]):
+    """Confidence-weighted majority over every successful result."""
+    try:
+        from ..team import _vote_signal
+        return _vote_signal(results)
+    except Exception:
+        return "HOLD", 0.0
+
+
+def _build_synthesis(themes, notes, team_synthesis, agree, quant) -> str:
+    parts: List[str] = []
+    if team_synthesis and team_synthesis.strip():
+        parts.append(team_synthesis.strip())
+    elif themes:
+        parts.append("；".join(t.summary for t in themes))
+    if notes:
+        parts.append("补充证据（深挖）：" + "；".join(notes))
+    if quant and quant.available:
+        if agree == "disagree":
+            parts.append(f"⚠️ 量化信号为 {quant.verdict()}，与定性方向相反，已下调置信度，建议人工复核。")
+        elif agree == "agree":
+            parts.append(f"量化信号（{quant.verdict()}）与定性方向一致，置信度已上调。")
+    return "\n\n".join(p for p in parts if p)
+
+
+class DeepAnalysisPipeline:
+    def __init__(self, llm_provider=None, data_router=None,
+                 store: Optional[CalibrationStore] = None, lang: str = "zh"):
+        self.llm = llm_provider
+        self.data = data_router
+        self.store = store if store is not None else CalibrationStore()
+        self.lang = lang
+
+    def analyze(
+        self,
+        symbol: str,
+        agent_results: List[AgentResult],
+        *,
+        team_synthesis: str = "",
+        quant_provider: Optional[Callable[[str], Dict[str, Dict]]] = None,
+        tool_runner: Optional[Callable[[str, Dict], Optional[Dict]]] = None,
+        deepen_result: Optional[tuple] = None,
+    ) -> DeepAnalysisResult:
+        """Deterministic assembly of the deep result (no LLM/network required).
+
+        ``deepen_result`` lets ``run()`` inject the LLM-driven (agentic) deepening
+        output; when absent the deterministic gap planner runs instead.
+        """
+        if not agent_results:
+            return DeepAnalysisResult(symbol=symbol, error="no_agent_results")
+
+        themes = group_by_theme(agent_results)                       # P1a
+        quant, qprov = gather_quant_evidence(symbol, quant_provider)  # P2
+        if deepen_result is not None:                                 # P0 (agentic, injected)
+            notes, dprov = deepen_result
+        else:
+            notes, dprov = deepen(symbol, themes, quant, tool_runner)  # P0 (deterministic)
+
+        raw_signal, raw_conf = _vote_all(agent_results)
+        cal_conf, agree = calibrate_confidence(raw_conf, raw_signal, quant, self.store)  # P2
+
+        kp_count = sum(len(t.key_points) for t in themes)
+        crit = critique(agent_results, raw_signal, cal_conf, quant, agree,  # P1b
+                        qprov + dprov, kp_count)
+
+        final_signal = raw_signal if crit.passed else soften_signal(raw_signal)
+        synthesis = _build_synthesis(themes, notes, team_synthesis, agree, quant)
+
+        return DeepAnalysisResult(
+            symbol=symbol,
+            final_signal=final_signal,
+            raw_confidence=raw_conf,
+            calibrated_confidence=cal_conf,
+            themes=themes,
+            quant=quant,
+            critique=crit,
+            provenance=qprov + dprov,
+            synthesis=synthesis,
+            agent_results=[r.to_dict() for r in agent_results],
+        )
+
+    async def run(
+        self,
+        symbol: str,
+        agents: Optional[List[str]] = None,
+        quant_provider: Optional[Callable] = None,
+        tool_runner: Optional[Callable] = None,
+        on_agent_done: Optional[Callable] = None,
+    ) -> DeepAnalysisResult:
+        t0 = time.time()
+        from ..team import AgentTeam
+        team = AgentTeam(llm_provider=self.llm, data_router=self.data,
+                         on_agent_done=on_agent_done, lang=self.lang)
+        tr = await team.run(symbol, agents=agents)
+
+        # P0 agentic deepening (LLM-driven tool loop) when an LLM is available.
+        deepen_result = None
+        if self.llm and tr.results:
+            try:
+                from .deepen import deepen_agentic
+                from .themes import group_by_theme as _grp
+                deepen_result = await deepen_agentic(
+                    symbol, _grp(tr.results), None, self.llm, tool_runner)
+            except Exception:
+                deepen_result = None
+
+        res = self.analyze(symbol, tr.results, team_synthesis=tr.synthesis,
+                           quant_provider=quant_provider, tool_runner=tool_runner,
+                           deepen_result=deepen_result)
+
+        # P1b LLM self-check — augments the deterministic critic when an LLM is present.
+        if self.llm and res.critique is not None and res.synthesis:
+            try:
+                from .critic import llm_critique, soften_signal
+                theme_sum = "；".join(t.summary for t in res.themes)
+                extra = await llm_critique(symbol, res.synthesis, theme_sum, self.llm)
+                if extra:
+                    had_high = bool(res.critique.high)
+                    res.critique.issues.extend(extra)
+                    new_high = any(i.severity == "high" for i in extra)
+                    if new_high:
+                        res.critique.passed = False
+                        # soften once if the deterministic pass had cleared it
+                        if not had_high:
+                            res.final_signal = soften_signal(res.final_signal)
+            except Exception:
+                pass
+
+        res.elapsed_sec = round(time.time() - t0, 1)
+        if tr.error and not tr.results:
+            res.error = tr.error
+        return res
+
+
+async def run_deep_analysis(symbol: str, llm_provider=None, data_router=None,
+                            agents: Optional[List[str]] = None, lang: str = "zh",
+                            **kw) -> DeepAnalysisResult:
+    """Convenience: run the full team + deep pipeline for ``symbol``."""
+    pipe = DeepAnalysisPipeline(llm_provider=llm_provider, data_router=data_router, lang=lang)
+    return await pipe.run(symbol, agents=agents, **kw)

aria_code/agents/deep/quant_fusion.py

@@ -0,0 +1,192 @@
+"""P2 — fuse quantitative ground truth and calibrate confidence.
+
+The qualitative team votes a signal with a self-reported confidence. That number
+is uncalibrated — an agent saying "80%" doesn't mean it's right 80% of the time.
+This layer:
+
+  1. gathers quant signals (AI signal, risk metrics, backtest) as ground truth,
+  2. nudges confidence by whether quant *agrees* with the qualitative verdict,
+  3. scales by a *reliability* factor learned from realised outcomes (CalibrationStore),
+
+so confidence drifts toward the historical hit-rate as outcomes accumulate.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Callable, Dict, Optional, Tuple
+
+from .models import QuantEvidence, Provenance
+
+_BULL = ("STRONG_BUY", "BUY")
+_BEAR = ("STRONG_SELL", "SELL")
+
+
+# ── gather quant evidence ─────────────────────────────────────────────────────
+def _default_provider(symbol: str) -> Dict[str, Dict]:
+    """Best-effort pull of quant signals from local_finance_tools (each optional)."""
+    out: Dict[str, Dict] = {}
+    try:
+        import local_finance_tools as lft
+    except Exception:
+        return out
+    for key, fn in (("ai", "_get_ai_signal"), ("risk", "_get_risk_metrics"),
+                    ("backtest", "_backtest_strategy"), ("factors", "_calculate_factors")):
+        f = getattr(lft, fn, None)
+        if not f:
+            continue
+        try:
+            res = f({"symbol": symbol})
+            if isinstance(res, dict) and res.get("success"):
+                out[key] = res
+        except Exception:
+            pass
+    return out
+
+
+def _num(d: Dict, *keys) -> Optional[float]:
+    for k in keys:
+        v = d.get(k)
+        if isinstance(v, (int, float)):
+            return float(v)
+    return None
+
+
+def gather_quant_evidence(
+    symbol: str,
+    provider: Optional[Callable[[str], Dict[str, Dict]]] = None,
+) -> Tuple[QuantEvidence, list]:
+    """Return (QuantEvidence, [Provenance]). Never raises."""
+    raw = {}
+    try:
+        raw = (provider or _default_provider)(symbol)
+    except Exception:
+        raw = {}
+
+    prov: list = []
+    ev = QuantEvidence()
+    if not raw:
+        ev.note = "no quant backend available"
+        return ev, prov
+
+    ai = raw.get("ai") or {}
+    if ai:
+        action = str(ai.get("action") or ai.get("signal") or "").upper()
+        ev.ai_signal = action or None
+        conf = _num(ai, "confidence") or 0.0
+        if action in _BULL:
+            ev.ai_score = conf
+        elif action in _BEAR:
+            ev.ai_score = -conf
+        else:
+            ev.ai_score = 0.0
+        prov.append(Provenance("ai_signal", str(ai.get("provider", "quant")), note=action))
+
+    risk = raw.get("risk") or {}
+    if risk:
+        ev.sharpe = _num(risk, "sharpe", "sharpe_ratio")
+        ev.max_drawdown = _num(risk, "max_drawdown", "max_dd")
+        prov.append(Provenance("risk_metrics", "local_finance", note="VaR/Sharpe"))
+
+    bt = raw.get("backtest") or {}
+    if bt:
+        ev.backtest_return = _num(bt, "total_return", "return", "cagr")
+        if ev.sharpe is None:
+            ev.sharpe = _num(bt, "sharpe", "sharpe_ratio")
+        if ev.max_drawdown is None:
+            ev.max_drawdown = _num(bt, "max_drawdown", "max_dd")
+        prov.append(Provenance("backtest", "local_finance", note=str(bt.get("strategy", ""))))
+
+    fac = raw.get("factors") or {}
+    if fac:
+        ev.ic = _num(fac, "ic", "information_coefficient")
+        ev.factors = {k: v for k, v in fac.items()
+                      if k not in ("success", "symbol") and isinstance(v, (int, float))}
+        prov.append(Provenance("factors", "local_finance"))
+
+    ev.available = bool(ai or risk or bt or fac)
+    return ev, prov
+
+
+# ── confidence calibration ────────────────────────────────────────────────────
+def _bucket(conf: float) -> str:
+    if conf < 0.4:
+        return "lo"
+    if conf < 0.7:
+        return "mid"
+    return "hi"
+
+
+def _side(signal: str) -> str:
+    if signal in _BULL:
+        return "bull"
+    if signal in _BEAR:
+        return "bear"
+    return "neutral"
+
+
+def agreement(agent_signal: str, quant_verdict: str) -> str:
+    a = _side(agent_signal)
+    q = {"BULLISH": "bull", "BEARISH": "bear", "NEUTRAL": "neutral"}.get(quant_verdict, "neutral")
+    if a == "neutral" or q == "neutral":
+        return "neutral"
+    return "agree" if a == q else "disagree"
+
+
+class CalibrationStore:
+    """Tracks realised hit-rate per (signal-side, confidence-bucket) on disk.
+
+    ``reliability(conf, signal)`` returns observed_hit_rate / nominal_confidence,
+    clamped to a sane band, so a chronically over-confident bucket gets damped and
+    an under-confident one gets a small boost. With no history it returns 1.0.
+    """
+
+    _NOMINAL = {"lo": 0.30, "mid": 0.55, "hi": 0.80}
+
+    def __init__(self, path: Optional[Path] = None):
+        self.path = Path(path or os.path.expanduser("~/.arthera/deep_calibration.json"))
+        self._data: Dict[str, Dict[str, int]] = {}
+        try:
+            if self.path.exists():
+                self._data = json.loads(self.path.read_text())
+        except Exception:
+            self._data = {}
+
+    def _key(self, side: str, bucket: str) -> str:
+        return f"{side}:{bucket}"
+
+    def reliability(self, conf: float, signal: str = "") -> float:
+        rec = self._data.get(self._key(_side(signal), _bucket(conf)))
+        if not rec or rec.get("n", 0) < 8:
+            return 1.0
+        hit = rec["hit"] / rec["n"]
+        nominal = self._NOMINAL[_bucket(conf)] or 1.0
+        return max(0.6, min(1.25, hit / nominal))
+
+    def record_outcome(self, signal: str, conf: float, correct: bool) -> None:
+        k = self._key(_side(signal), _bucket(conf))
+        rec = self._data.setdefault(k, {"n": 0, "hit": 0})
+        rec["n"] += 1
+        rec["hit"] += 1 if correct else 0
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(json.dumps(self._data, indent=2))
+        except Exception:
+            pass
+
+
+def calibrate_confidence(
+    raw_conf: float,
+    agent_signal: str,
+    quant: QuantEvidence,
+    store: Optional[CalibrationStore] = None,
+) -> Tuple[float, str]:
+    """Return (calibrated_confidence, agreement_label)."""
+    agree = agreement(agent_signal, quant.verdict()) if quant and quant.available else "neutral"
+    factor = {"agree": 1.15, "neutral": 1.0, "disagree": 0.70}[agree]
+    rel = store.reliability(raw_conf, agent_signal) if store else 1.0
+    cal = max(0.0, min(1.0, raw_conf * factor * rel))
+    return cal, agree

aria_code/agents/deep/themes.py

@@ -0,0 +1,95 @@
+"""P1a — group agent results by theme and build a per-theme sub-synthesis.
+
+Flat synthesis ("here are 8 opinions, here's the average") loses structure. Real
+research clusters evidence: what does *valuation* say, what does *momentum* say,
+what does *risk* say — then reconciles across clusters. This module does the
+clustering and a deterministic per-cluster roll-up (no LLM needed).
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Tuple
+
+from ..base import AgentResult
+from .models import ThemeGroup
+
+# Which theme each agent belongs to. Unknown agents fall into "other".
+_AGENT_THEME = {
+    "fundamental": "valuation",
+    "earnings":    "valuation",
+    "technical":   "momentum",
+    "risk":        "risk",
+    "news":        "catalysts",
+    "catalyst":    "catalysts",
+    "macro":       "macro",
+    "sector":      "macro",
+    "northbound":  "macro",
+    "debate":      "reconciliation",
+}
+
+# Display order + human labels.
+_THEME_ORDER = ["valuation", "momentum", "macro", "catalysts", "risk",
+                "reconciliation", "other"]
+_THEME_LABEL = {
+    "valuation":      "估值/基本面",
+    "momentum":       "动量/技术",
+    "macro":          "宏观/板块",
+    "catalysts":      "催化/消息",
+    "risk":           "风险",
+    "reconciliation": "分歧调解",
+    "other":          "其他",
+}
+
+_SCORE = {"STRONG_BUY": 2, "BUY": 1, "HOLD": 0, "SELL": -1, "STRONG_SELL": -2}
+
+
+def theme_of(agent_name: str) -> str:
+    return _AGENT_THEME.get(agent_name, "other")
+
+
+def _vote(results: List[AgentResult]) -> Tuple[str, float]:
+    """Confidence-weighted majority within a single theme."""
+    valid = [r for r in results if r.success and r.signal in _SCORE]
+    if not valid:
+        return "HOLD", 0.0
+    avg_score = sum(_SCORE[r.signal] * r.confidence for r in valid) / len(valid)
+    avg_conf = sum(r.confidence for r in valid) / len(valid)
+    if avg_score >= 1.5:
+        return "STRONG_BUY", avg_conf
+    if avg_score >= 0.5:
+        return "BUY", avg_conf
+    if avg_score <= -1.5:
+        return "STRONG_SELL", avg_conf
+    if avg_score <= -0.5:
+        return "SELL", avg_conf
+    return "HOLD", avg_conf
+
+
+def group_by_theme(results: List[AgentResult]) -> List[ThemeGroup]:
+    """Cluster agent results into themes with a per-theme signal + summary."""
+    buckets: Dict[str, List[AgentResult]] = {}
+    for r in results:
+        buckets.setdefault(theme_of(r.agent), []).append(r)
+
+    groups: List[ThemeGroup] = []
+    for theme in _THEME_ORDER:
+        members = buckets.get(theme)
+        if not members:
+            continue
+        signal, conf = _vote(members)
+        points: List[str] = []
+        for r in members:
+            if r.success:
+                points.extend((r.key_points or [])[:2])
+        ok = sum(1 for r in members if r.success)
+        summary = (f"{_THEME_LABEL[theme]}: {signal}（{ok}/{len(members)} agent 有效，"
+                   f"置信度 {conf:.0%}）")
+        groups.append(ThemeGroup(
+            theme=_THEME_LABEL[theme],
+            agents=[r.agent for r in members],
+            signal=signal,
+            confidence=conf,
+            summary=summary,
+            key_points=points[:5],
+        ))
+    return groups

aria_code/agents/deep/tiers.py

@@ -0,0 +1,106 @@
+"""P3 — render the deep result at three depths, with data provenance.
+
+  brief    — one glance: signal, calibrated confidence, headline
+  standard — + per-theme roll-up + synthesis
+  deep     — + quant evidence + critique + provenance (data lineage) + agent points
+
+Pure text/markdown so it renders in the terminal; the HTML report layer can reuse
+the same DeepAnalysisResult.
+"""
+
+from __future__ import annotations
+
+from .models import DeepAnalysisResult
+
+_SIGNAL_ICON = {
+    "STRONG_BUY": "🟢🟢", "BUY": "🟢", "HOLD": "⚪",
+    "SELL": "🔴", "STRONG_SELL": "🔴🔴",
+}
+
+
+def _headline(r: DeepAnalysisResult) -> str:
+    icon = _SIGNAL_ICON.get(r.final_signal, "⚪")
+    conf = f"{r.calibrated_confidence:.0%}"
+    note = ""
+    if r.raw_confidence and abs(r.calibrated_confidence - r.raw_confidence) >= 0.05:
+        note = f"（原始 {r.raw_confidence:.0%} → 校准 {conf}）"
+    else:
+        note = f"（置信度 {conf}）"
+    return f"{icon} **{r.symbol} · {r.final_signal}** {note}"
+
+
+def render_brief(r: DeepAnalysisResult) -> str:
+    lines = [_headline(r)]
+    if r.quant and r.quant.available:
+        lines.append(f"  量化: {r.quant.verdict()}"
+                     + (f" · IC {r.quant.ic:.2f}" if r.quant.ic is not None else "")
+                     + (f" · Sharpe {r.quant.sharpe:.2f}" if r.quant.sharpe is not None else ""))
+    if r.critique and r.critique.high:
+        lines.append(f"  ⚠️ {r.critique.high[0].message}")
+    return "\n".join(lines)
+
+
+def render_standard(r: DeepAnalysisResult) -> str:
+    parts = [render_brief(r), ""]
+    if r.themes:
+        parts.append("### 分主题")
+        for t in r.themes:
+            parts.append(f"- {t.summary}")
+        parts.append("")
+    if r.synthesis:
+        parts.append("### 综合")
+        parts.append(r.synthesis)
+    return "\n".join(parts).rstrip()
+
+
+def render_deep(r: DeepAnalysisResult) -> str:
+    parts = [render_standard(r), ""]
+
+    if r.quant and r.quant.available:
+        q = r.quant
+        parts.append("### 量化地面真值")
+        row = []
+        if q.ai_signal:           row.append(f"AI信号 {q.ai_signal}")
+        if q.ai_score is not None:row.append(f"分值 {q.ai_score:+.2f}")
+        if q.ic is not None:      row.append(f"IC {q.ic:.3f}")
+        if q.sharpe is not None:  row.append(f"Sharpe {q.sharpe:.2f}")
+        if q.max_drawdown is not None: row.append(f"MaxDD {q.max_drawdown:.1%}")
+        if q.backtest_return is not None: row.append(f"回测收益 {q.backtest_return:+.1%}")
+        parts.append("- " + " · ".join(row) if row else "- (无)")
+        parts.append("")
+
+    if r.critique is not None:
+        parts.append("### 自检 (Critic)")
+        mark = "✅ 通过" if r.critique.passed else "❌ 存在高危问题"
+        parts.append(f"结论: {mark}" + ("（无问题）" if not r.critique.issues else ""))
+        for i in r.critique.issues:
+            sev = {"high": "🔴", "medium": "🟡", "low": "⚪"}.get(i.severity, "·")
+            parts.append(f"- {sev} [{i.kind}] {i.message}")
+        parts.append("")
+
+    if r.provenance:
+        parts.append("### 数据血缘")
+        parts.append("| 字段 | 来源 | 时效 | 备注 |")
+        parts.append("|------|------|------|------|")
+        for p in r.provenance:
+            parts.append(f"| {p.field} | {p.source} | {p.freshness} | {p.note} |")
+        parts.append("")
+
+    if r.agent_results:
+        parts.append("### 各 Agent 要点")
+        for a in r.agent_results:
+            if a.get("error"):
+                parts.append(f"- **{a['agent']}** ⚠️ {a['error']}")
+                continue
+            pts = a.get("key_points") or []
+            head = f"- **{a['agent']}** ({a.get('signal','?')}, {a.get('confidence',0):.0%})"
+            parts.append(head)
+            for pt in pts[:3]:
+                parts.append(f"    • {pt}")
+
+    return "\n".join(parts).rstrip()
+
+
+def render_tier(r: DeepAnalysisResult, tier: str = "standard") -> str:
+    return {"brief": render_brief, "standard": render_standard,
+            "deep": render_deep}.get(tier, render_standard)(r)

aria_code/agents/engineering/__init__.py

@@ -0,0 +1,14 @@
+"""
+agents/engineering/__init__.py — Engineering & Code Execution Agents
+===================================================================
+Provides Coder, Tester, and Self-Healing Debugger agents for Aria Code.
+"""
+
+from .coder import CoderAgent
+from .tester import TesterAgent, TesterSelfHealingAgent
+
+__all__ = [
+    "CoderAgent",
+    "TesterAgent",
+    "TesterSelfHealingAgent",
+]