aria-code 0.52.0__py3-none-any.whl

aria_code/agents/code_review.py

@@ -0,0 +1,200 @@
+"""Deterministic, read-only code review agent.
+
+The agent deliberately reviews caller-supplied text only.  It never resolves a
+path, invokes a shell, or changes a workspace, so it can be used safely from
+both the CLI and a Google ADK function tool.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import dataclass
+from pathlib import PurePath
+from typing import Any, Dict, Iterable, List
+
+from .base import AgentResult, BaseAgent
+
+
+@dataclass(frozen=True)
+class CodeReviewFinding:
+    """A stable, evidence-bearing static-review finding."""
+
+    severity: str
+    rule: str
+    message: str
+    line: int | None
+    evidence: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "severity": self.severity,
+            "rule": self.rule,
+            "message": self.message,
+            "line": self.line,
+            "evidence": self.evidence,
+        }
+
+
+class CodeReviewAgent(BaseAgent):
+    """Find high-signal correctness and security hazards without an LLM."""
+
+    name = "code_review"
+    description = "Read-only deterministic code review for user-supplied snippets and diffs"
+    MAX_SOURCE_CHARS = 48_000
+    _SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+    _SECRET_ASSIGNMENT = re.compile(
+        r"\b(?:api[_-]?key|secret|token|password)\b\s*=\s*['\"][^'\"]{8,}['\"]",
+        re.IGNORECASE,
+    )
+    _TOKEN_LITERAL = re.compile(r"\b(?:(?:ghp|github_pat)_[A-Za-z0-9_-]{12,}|sk-[A-Za-z0-9_-]{12,})\b", re.IGNORECASE)
+    _SHELL_TRUE = re.compile(r"\b(?:subprocess\.[A-Za-z_]+|os\.system)\b.*\bshell\s*=\s*True", re.IGNORECASE)
+    _EVAL_EXEC = re.compile(r"\b(?:eval|exec)\s*\(")
+    _PICKLE = re.compile(r"\bpickle\.loads?\s*\(")
+    _UNSAFE_YAML = re.compile(r"\byaml\.load\s*\(")
+    _TLS_DISABLED = re.compile(r"\brequests\.[A-Za-z_]+\s*\(.*\bverify\s*=\s*False", re.IGNORECASE)
+
+    @staticmethod
+    def _safe_filename(filename: str) -> str:
+        name = PurePath(str(filename or "snippet.py")).name
+        return name[:160] or "snippet.py"
+
+    @classmethod
+    def _append(
+        cls,
+        findings: List[CodeReviewFinding],
+        severity: str,
+        rule: str,
+        message: str,
+        line: int | None,
+        evidence: str,
+    ) -> None:
+        if rule == "hardcoded-secret":
+            evidence = "<credential value redacted>"
+        findings.append(
+            CodeReviewFinding(
+                severity=severity,
+                rule=rule,
+                message=message,
+                line=line,
+                evidence=evidence.strip()[:240],
+            )
+        )
+
+    @classmethod
+    def _scan_lines(cls, lines: Iterable[str], findings: List[CodeReviewFinding]) -> None:
+        for number, line in enumerate(lines, start=1):
+            if cls._SECRET_ASSIGNMENT.search(line) or cls._TOKEN_LITERAL.search(line):
+                cls._append(
+                    findings, "high", "hardcoded-secret",
+                    "疑似硬编码凭据；改用环境变量或受管密钥，并立即轮换已暴露的值。",
+                    number, line,
+                )
+            if cls._SHELL_TRUE.search(line):
+                cls._append(
+                    findings, "high", "shell-true",
+                    "shell=True 会把不可信输入交给 shell 解释；改用参数列表和严格的输入校验。",
+                    number, line,
+                )
+            if cls._EVAL_EXEC.search(line):
+                cls._append(
+                    findings, "high", "dynamic-execution",
+                    "eval/exec 可执行不可信文本；使用受限解析器或显式分发表。",
+                    number, line,
+                )
+            if cls._PICKLE.search(line):
+                cls._append(
+                    findings, "high", "unsafe-deserialization",
+                    "pickle 反序列化不可信数据可执行任意代码；改用 JSON 或签名的可信工件。",
+                    number, line,
+                )
+            if cls._UNSAFE_YAML.search(line) and "Loader=" not in line:
+                cls._append(
+                    findings, "high", "unsafe-yaml-load",
+                    "yaml.load 未指定安全 Loader；使用 yaml.safe_load。",
+                    number, line,
+                )
+            if cls._TLS_DISABLED.search(line):
+                cls._append(
+                    findings, "high", "tls-verification-disabled",
+                    "TLS 证书校验被关闭；除受控测试外不得使用 verify=False。",
+                    number, line,
+                )
+
+    @classmethod
+    def review_source(
+        cls,
+        source: str,
+        *,
+        filename: str = "snippet.py",
+        language: str = "python",
+        is_diff: bool = False,
+    ) -> List[CodeReviewFinding]:
+        """Review source text or an already-provided diff without touching disk."""
+        if not isinstance(source, str) or not source.strip():
+            return [CodeReviewFinding("medium", "empty-input", "没有可审查的代码内容。", None, "")]
+        if len(source) > cls.MAX_SOURCE_CHARS:
+            return [CodeReviewFinding(
+                "medium", "input-truncated",
+                f"审查输入超过 {cls.MAX_SOURCE_CHARS} 字符；请按文件或提交拆分后复查。",
+                None, "",
+            )]
+
+        findings: List[CodeReviewFinding] = []
+        lines = source.splitlines()
+        scan_lines = [line[1:] for line in lines if line.startswith("+") and not line.startswith("+++")] if is_diff else lines
+        cls._scan_lines(scan_lines, findings)
+
+        inferred_python = language.lower() in {"py", "python"} or cls._safe_filename(filename).endswith(".py")
+        if inferred_python and not is_diff:
+            try:
+                tree = ast.parse(source, filename=cls._safe_filename(filename))
+            except SyntaxError as exc:
+                cls._append(
+                    findings, "critical", "python-syntax-error",
+                    "Python 代码无法解析，运行前会失败。",
+                    exc.lineno, (exc.text or "").strip(),
+                )
+            else:
+                for node in ast.walk(tree):
+                    if isinstance(node, ast.ExceptHandler) and node.type is None:
+                        cls._append(
+                            findings, "medium", "bare-except",
+                            "裸 except 会吞掉系统退出和中断；至少捕获 Exception，并记录或处理错误。",
+                            node.lineno, "except:",
+                        )
+
+        unique = {(item.rule, item.line, item.evidence): item for item in findings}
+        return sorted(unique.values(), key=lambda item: (cls._SEVERITY_ORDER[item.severity], item.line or 0, item.rule))
+
+    @classmethod
+    def format_findings(cls, findings: List[CodeReviewFinding]) -> str:
+        if not findings:
+            return "确定性检查未发现已覆盖规则中的问题；仍需执行测试并进行语义审查。"
+        rows = []
+        for finding in findings:
+            location = f"第 {finding.line} 行" if finding.line else "输入级"
+            rows.append(f"[{finding.severity.upper()}] {location} {finding.rule}: {finding.message}")
+        return "\n".join(rows)
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        source = str(data.get("source") or data.get("content") or data.get("diff") or "")
+        filename = self._safe_filename(str(data.get("filename") or symbol or "snippet.py"))
+        findings = self.review_source(
+            source,
+            filename=filename,
+            language=str(data.get("language") or "python"),
+            is_diff=bool(data.get("is_diff")),
+        )
+        return AgentResult(
+            agent=self.name,
+            symbol=filename,
+            analysis=self.format_findings(findings),
+            confidence=0.99 if source else 0.0,
+            signal="HOLD",
+            key_points=[f"{item.severity}: {item.rule}" for item in findings[:8]],
+            data_used={"filename": filename, "finding_count": len(findings)},
+            degraded=False,
+            provenance=["deterministic_static_review"],
+            limitations=["只审查调用方提供的文本；不会读取文件、执行命令或运行测试。"],
+        )

aria_code/agents/deep/__init__.py

@@ -0,0 +1,37 @@
+"""Deep analysis pipeline — Claude-Code-style layered research on top of AgentTeam.
+
+Adds the four "deep" layers the flat team pipeline was missing:
+
+  P0  deepen      — tool-augmented evidence gathering for material/uncertain findings
+  P1  hierarchical + critic — theme-grouped sub-synthesis, then a self-check pass
+  P2  quant fusion — fuse ML/backtest/risk signals as ground truth + calibrate confidence
+  P3  tiered output + provenance — brief / standard / deep reports with data lineage
+
+Everything degrades gracefully: any layer whose dependency (LLM, quant tools, data
+cleaner) is unavailable is skipped, never raised. The deterministic parts (theme
+grouping, calibration math, critic rules, tier rendering) run with no LLM/network,
+which keeps the pipeline testable.
+"""
+
+from __future__ import annotations
+
+from .models import (
+    Critique,
+    CritiqueIssue,
+    DeepAnalysisResult,
+    Provenance,
+    QuantEvidence,
+    ThemeGroup,
+)
+from .pipeline import DeepAnalysisPipeline, run_deep_analysis
+
+__all__ = [
+    "Critique",
+    "CritiqueIssue",
+    "DeepAnalysisResult",
+    "Provenance",
+    "QuantEvidence",
+    "ThemeGroup",
+    "DeepAnalysisPipeline",
+    "run_deep_analysis",
+]

aria_code/agents/deep/calibration_loop.py

@@ -0,0 +1,144 @@
+"""P2 closed loop — log predictions, later score them against realised price.
+
+Calibration only improves if confidence is checked against what actually happened.
+This module:
+
+  1. logs every deep verdict (symbol, signal, confidence, reference price, time),
+  2. once a prediction's horizon has elapsed, fetches the realised return and
+     marks it correct/incorrect,
+  3. feeds the outcome into CalibrationStore so the reliability factor — and thus
+     future calibrated confidence — drifts toward the true hit-rate.
+
+Everything is injectable (price function, clock) so it tests without network.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import Callable, Dict, List, Optional
+
+from .quant_fusion import CalibrationStore
+
+_BULL = ("STRONG_BUY", "BUY")
+_BEAR = ("STRONG_SELL", "SELL")
+
+
+def correctness(signal: str, ret: float, threshold: float = 0.02) -> bool:
+    """Was the call right given the realised return?"""
+    if signal in _BULL:
+        return ret > threshold
+    if signal in _BEAR:
+        return ret < -threshold
+    return abs(ret) <= threshold       # HOLD: right when it stayed flat
+
+
+class PredictionLog:
+    """Append-only log of deep verdicts, JSON-list backed (low volume)."""
+
+    def __init__(self, path: Optional[Path] = None):
+        self.path = Path(path or os.path.expanduser("~/.arthera/deep_predictions.json"))
+        self._items: List[Dict] = []
+        try:
+            if self.path.exists():
+                self._items = json.loads(self.path.read_text())
+        except Exception:
+            self._items = []
+
+    def _save(self) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(json.dumps(self._items, ensure_ascii=False, indent=2))
+        except Exception:
+            pass
+
+    def log(self, symbol: str, signal: str, confidence: float,
+            ref_price: float, ts: Optional[float] = None) -> str:
+        pid = uuid.uuid4().hex[:12]
+        self._items.append({
+            "id": pid, "symbol": symbol, "signal": signal,
+            "confidence": float(confidence), "ref_price": float(ref_price),
+            "ts": ts if ts is not None else time.time(), "evaluated": False,
+        })
+        self._save()
+        return pid
+
+    def pending(self, horizon_days: float, now: Optional[float] = None) -> List[Dict]:
+        now = now if now is not None else time.time()
+        cutoff = now - horizon_days * 86400
+        return [p for p in self._items if not p.get("evaluated") and p["ts"] <= cutoff]
+
+    def mark_evaluated(self, pid: str, ret: float, correct: bool,
+                       source: str = "price") -> None:
+        for p in self._items:
+            if p["id"] == pid:
+                p["evaluated"] = True
+                p["realised_return"] = ret
+                p["correct"] = correct
+                p["source"] = source
+                break
+        self._save()
+
+
+def evaluate_due(
+    store: CalibrationStore,
+    log: PredictionLog,
+    price_fn: Callable[[str], Optional[float]],
+    horizon_days: float = 5.0,
+    threshold: float = 0.02,
+    now: Optional[float] = None,
+) -> Dict[str, int]:
+    """Score every prediction past its horizon and update calibration. Returns counts."""
+    evaluated = hits = 0
+    for p in log.pending(horizon_days, now=now):
+        try:
+            cur = price_fn(p["symbol"])
+        except Exception:
+            cur = None
+        if not cur or not p.get("ref_price"):
+            continue
+        ret = (cur - p["ref_price"]) / p["ref_price"]
+        ok = correctness(p["signal"], ret, threshold)
+        store.record_outcome(p["signal"], p["confidence"], ok)
+        log.mark_evaluated(p["id"], round(ret, 5), ok)
+        evaluated += 1
+        hits += 1 if ok else 0
+    return {"evaluated": evaluated, "hits": hits,
+            "hit_rate": round(hits / evaluated, 3) if evaluated else 0.0}
+
+
+def evaluate_from_ledger(
+    store: CalibrationStore,
+    log: PredictionLog,
+    ledger,
+) -> Dict[str, int]:
+    """Score predictions against the portfolio ledger's REALISED P&L (actual closed
+    trades) — a stronger ground truth than market price for symbols you traded.
+
+    BUY is right when the symbol's realised P&L is positive, SELL when negative.
+    HOLD is skipped (no clean threshold without a cost basis). ``ledger`` is any
+    object exposing ``get_realized_pnl() -> [{symbol, realized_pnl, ...}]``.
+    """
+    try:
+        realized = ledger.get_realized_pnl()
+    except Exception:
+        return {"evaluated": 0, "hits": 0, "hit_rate": 0.0}
+    pnl_map = {str(r.get("symbol", "")).upper(): r.get("realized_pnl", 0.0)
+               for r in (realized or []) if r.get("realized_pnl")}
+
+    evaluated = hits = 0
+    for p in log.pending(0.0):          # any un-evaluated prediction
+        sym = str(p["symbol"]).upper()
+        if sym not in pnl_map or p["signal"] not in (_BULL + _BEAR):
+            continue
+        pnl = pnl_map[sym]
+        ok = (pnl > 0) if p["signal"] in _BULL else (pnl < 0)
+        store.record_outcome(p["signal"], p["confidence"], ok)
+        log.mark_evaluated(p["id"], round(pnl, 2), ok, source="ledger")
+        evaluated += 1
+        hits += 1 if ok else 0
+    return {"evaluated": evaluated, "hits": hits,
+            "hit_rate": round(hits / evaluated, 3) if evaluated else 0.0}

aria_code/agents/deep/critic.py

@@ -0,0 +1,125 @@
+"""P1b — a self-check pass over the assembled analysis.
+
+Claude Code verifies its own work; the flat pipeline never did. The critic applies
+deterministic rules (no LLM, fully testable) to flag the failure modes that quietly
+ruin a research note: thin agent coverage, no risk angle, a strong call on weak
+confidence, or the quant signal contradicting the qualitative verdict. An optional
+LLM pass can add free-text findings on top.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from ..base import AgentResult
+from .models import Critique, CritiqueIssue, Provenance, QuantEvidence
+from .themes import theme_of
+
+_STRONG = ("STRONG_BUY", "STRONG_SELL")
+
+
+def critique(
+    agent_results: List[AgentResult],
+    final_signal: str,
+    calibrated_confidence: float,
+    quant: Optional[QuantEvidence] = None,
+    agreement: str = "neutral",
+    provenance: Optional[List[Provenance]] = None,
+    key_point_count: int = 0,
+) -> Critique:
+    """Deterministic self-check. Returns a Critique; ``passed`` is False on any
+    high-severity issue so the caller can soften an over-confident conclusion."""
+    issues: List[CritiqueIssue] = []
+
+    total = len(agent_results)
+    ok = sum(1 for r in agent_results if r.success)
+
+    # 1) coverage
+    if ok < 2:
+        issues.append(CritiqueIssue("high", "thin_coverage",
+            f"只有 {ok} 个 agent 成功，结论证据不足，不应作为决策依据。"))
+    elif total and ok / total < 0.5:
+        issues.append(CritiqueIssue("medium", "thin_coverage",
+            f"{total - ok}/{total} 个 agent 失败，覆盖偏薄。"))
+
+    # 2) risk angle present?
+    has_risk = any(r.success and theme_of(r.agent) == "risk" for r in agent_results)
+    if not has_risk:
+        issues.append(CritiqueIssue("medium", "missing_risk",
+            "缺少有效的风险维度分析，下行风险可能被低估。"))
+
+    # 3) quant contradicts qualitative verdict
+    if quant and quant.available and agreement == "disagree":
+        issues.append(CritiqueIssue("high", "conflict",
+            f"量化信号（{quant.verdict()}）与定性结论（{final_signal}）相反，置信度已下调；建议人工复核。"))
+
+    # 4) strong call on weak confidence
+    if final_signal in _STRONG and calibrated_confidence < 0.5:
+        issues.append(CritiqueIssue("medium", "unsupported",
+            f"给出强信号 {final_signal} 但校准后置信度仅 {calibrated_confidence:.0%}，"
+            "强度与把握不匹配。"))
+
+    # 5) strong call with little supporting evidence
+    if final_signal in _STRONG and key_point_count < 3:
+        issues.append(CritiqueIssue("medium", "unsupported",
+            "强信号但关键论据少于 3 条，论证偏薄。"))
+
+    # 6) stale data
+    for p in (provenance or []):
+        if p.freshness.endswith("d old"):
+            issues.append(CritiqueIssue("low", "stale_data",
+                f"{p.field} 数据为 {p.freshness}（来源 {p.source}），注意时效。"))
+
+    passed = not any(i.severity == "high" for i in issues)
+    return Critique(issues=issues, passed=passed)
+
+
+def soften_signal(final_signal: str) -> str:
+    """Step a verdict one notch toward HOLD (used when the critic fails)."""
+    ladder = {"STRONG_BUY": "BUY", "BUY": "HOLD", "HOLD": "HOLD",
+              "SELL": "HOLD", "STRONG_SELL": "SELL"}
+    return ladder.get(final_signal, "HOLD")
+
+
+_SEV = {"高": "high", "中": "medium", "低": "low",
+        "high": "high", "medium": "medium", "low": "low"}
+
+
+def parse_llm_issues(text: str, max_issues: int = 3) -> List[CritiqueIssue]:
+    """Parse the LLM reviewer's reply (``高|问题`` per line) into issues. Pure/testable."""
+    import re
+    issues: List[CritiqueIssue] = []
+    for line in (text or "").splitlines():
+        line = line.strip().lstrip("-•*0123456789. ").strip()
+        if not line or line.upper().startswith("OK") or line in ("无", "无问题"):
+            continue
+        parts = re.split(r"[|｜:：]", line, maxsplit=1)
+        if len(parts) == 2 and _SEV.get(parts[0].strip().lower()):
+            sev, msg = _SEV[parts[0].strip().lower()], parts[1].strip()
+        else:
+            sev, msg = "medium", line
+        if msg:
+            issues.append(CritiqueIssue(sev, "llm_review", msg))
+        if len(issues) >= max_issues:
+            break
+    return issues
+
+
+async def llm_critique(
+    symbol: str,
+    synthesis: str,
+    theme_summaries: str,
+    llm,
+    max_issues: int = 3,
+) -> List[CritiqueIssue]:
+    """Optional LLM reviewer — flags unsupported claims / missing risk / contradiction
+    / overconfidence in the synthesis. Returns extra issues (empty if no LLM)."""
+    if llm is None or not (synthesis or "").strip():
+        return []
+    from .deepen import _collect_llm
+    system = ("你是严格的研究审稿人。只挑【确凿的】问题：无数据支撑的论断、漏掉的下行风险、"
+              "自相矛盾、过度自信。每行一个，格式 `高|问题` / `中|问题` / `低|问题`，"
+              f"最多 {max_issues} 条。没有问题就只输出 OK。不要多余的话。")
+    user = f"标的: {symbol}\n各维度小结: {theme_summaries}\n\n综合结论:\n{synthesis}\n\n审查:"
+    resp = await _collect_llm(llm, system, user, max_tokens=300)
+    return parse_llm_issues(resp, max_issues)