aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/__init__.py

@@ -0,0 +1,49 @@
+"""
+agents/ — Aria Code 可组合多智能体系统
+=======================================
+用户可在项目根放置 aria_agents/ 目录，其中的 Agent 类自动被发现。
+
+内置 Agent:
+  macro       → 宏观环境、利率、行业周期
+  fundamental → 财务指标、估值、竞争壁垒
+  technical   → 图形形态、动量、关键价位
+  risk        → 风险评分、仓位建议
+  synthesis   → 汇总以上，输出可操作建议
+
+自定义 Agent 示例 (aria_agents/northbound_agent.py):
+    from agents.base import BaseAgent, AgentResult
+
+    class NorthboundAgent(BaseAgent):
+        name        = "northbound"
+        description = "北向资金分析专家"
+
+        async def analyze(self, symbol: str, data: dict) -> AgentResult:
+            ...
+"""
+
+# Keep the public analysis-agent API, without eager registration of every domain.
+# Task-agent capabilities must not initialize finance/vendor SDKs on import.
+from importlib import import_module
+
+_EXPORTS = {
+    "BaseAgent": (".base", "BaseAgent"), "AgentResult": (".base", "AgentResult"),
+    "AgentRegistry": (".registry", "AgentRegistry"), "get_registry": (".registry", "get_registry"),
+    "AgentTeam": (".team", "AgentTeam"), "run_team": (".team", "run_team"),
+    "SignalScheme": (".signal_scheme", "SignalScheme"),
+    "FINANCIAL_SCHEME": (".signal_scheme", "FINANCIAL_SCHEME"),
+    "REALTY_SCHEME": (".signal_scheme", "REALTY_SCHEME"),
+}
+__all__ = list(_EXPORTS)
+
+
+def __getattr__(name):
+    if name not in _EXPORTS:
+        raise AttributeError(name)
+    module, attribute = _EXPORTS[name]
+    value = getattr(import_module(module, __name__), attribute)
+    globals()[name] = value
+    return value
+
+
+def __dir__():
+    return sorted(set(globals()) | set(__all__))

aria_code/agents/base.py

@@ -0,0 +1,329 @@
+"""
+agents/base.py — Agent 统一抽象基类
+=====================================
+所有 agent 继承 BaseAgent，实现 analyze() 方法。
+LLM provider 和数据源从外部注入，agent 本身不关心底层实现。
+"""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Generator, AsyncGenerator
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AgentResult:
+    """Agent 分析结果，统一输出格式"""
+    agent:       str                    # agent 名称
+    symbol:      str                    # 分析标的
+    analysis:    str                    # 核心分析文本
+    confidence:  float                  # 置信度 0.0-1.0
+    signal:      str = "HOLD"           # BUY / HOLD / SELL / STRONG_BUY / STRONG_SELL
+    key_points:  List[str] = field(default_factory=list)   # 关键结论（用于 synthesis）
+    data_used:   Dict[str, Any] = field(default_factory=dict)  # 使用的原始数据
+    error:       Optional[str] = None   # 失败时的错误信息
+    degraded:    bool = False           # True when a deterministic fallback was used
+    provenance:  List[str] = field(default_factory=list)
+    limitations: List[str] = field(default_factory=list)
+
+    @property
+    def success(self) -> bool:
+        return self.error is None
+
+    def to_dict(self) -> Dict:
+        return {
+            "agent":      self.agent,
+            "symbol":     self.symbol,
+            "analysis":   self.analysis,
+            "confidence": self.confidence,
+            "signal":     self.signal,
+            "key_points": self.key_points,
+            "error":      self.error,
+            "degraded":   self.degraded,
+            "provenance": list(self.provenance),
+            "limitations": list(self.limitations),
+        }
+
+
+class BaseAgent(ABC):
+    """
+    所有 Agent 的抽象基类。
+
+    子类必须声明:
+        name:        str   — 唯一标识（用于 /team --agents macro,fundamental）
+        description: str   — 简短描述（显示在 /help 中）
+
+    子类必须实现:
+        analyze(symbol, data) → AgentResult
+
+    可选覆盖:
+        fetch_data(symbol) → dict  — 自定义数据获取逻辑
+    """
+
+    name:        str = "base"
+    description: str = "基础 Agent"
+
+    # Time-sensitive claims must come from a tool result with a timestamp, not
+    # from a hard-coded prompt.  This is appended to every agent because a
+    # wrong IPO/symbol/event claim can otherwise contaminate all specialisms.
+    _TIME_SENSITIVE_FACT_POLICY = (
+        "\n\n## Time-sensitive fact policy\n"
+        "- Do not treat examples, aliases, model memory, or internal notes as current facts.\n"
+        "- Verify ticker identity, IPO/listing status, prices, corporate events, sports results, "
+        "and dates with an appropriate tool or source before stating them as facts.\n"
+        "- If a current fact cannot be verified, say that it is unverified instead of guessing.\n"
+    )
+
+    # Language rule injected per-call based on detected user language
+    _LANG_RULES = {
+        "zh": "\n\n## Language rule\nRespond in Chinese (中文). Technical terms (RSI, MACD, P/E, EPS) may stay in English.\n",
+        "en": "\n\n## Language rule\nRespond in English.\n",
+    }
+
+    def __init__(
+        self,
+        llm_provider=None,         # BaseLLMProvider 实例（可选，None 则用模板生成）
+        data_router=None,          # DataRouter 实例（可选）
+        on_token: Optional[Callable[[str], None]] = None,  # 流式 token 回调
+        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, # 工具调用结束回调
+        config: Optional[Dict] = None,
+        lang: str = "zh",          # user language: "zh" | "en"
+    ):
+        self.llm      = llm_provider
+        self.data     = data_router
+        self.on_token = on_token
+        self.on_thought = on_thought
+        self.on_tool_start = on_tool_start
+        self.on_tool_end = on_tool_end
+        self.config   = config or {}
+        self.lang     = lang
+        self.llm_error: Optional[str] = None   # why the last model call gave nothing, if it failed
+        self.memory   = []         # Short-term conversation history for multi-turn context
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        """
+        从数据路由器获取分析所需数据。
+        子类可覆盖此方法以自定义数据获取逻辑。
+        """
+        if not self.data:
+            return {}
+        result = {}
+        try:
+            q = self.data.quote(symbol)
+            if q:
+                result["quote"] = q.to_dict()
+        except Exception as e:
+            logger.debug(f"[{self.name}] fetch quote {symbol}: {e}")
+        return result
+
+    def _data_guard(self, quote: Dict[str, Any]) -> str:
+        """Return a warning string if real data is unavailable; empty string if data is present."""
+        price = quote.get("price") if quote else None
+        if not price or float(price) == 0:
+            return (
+                "\n\n## ⛔ DATA UNAVAILABLE — STRICT RULES\n"
+                "Real market data could not be fetched (price=0 or missing).\n"
+                "You MUST:\n"
+                "1. State clearly that no real data is available.\n"
+                "2. NEVER invent specific prices, P/E ratios, EPS, revenue, RSI, MACD, or any numbers.\n"
+                "3. NEVER give specific price targets, stop-loss levels, or entry prices.\n"
+                "4. Give only qualitative analysis based on publicly known company characteristics.\n"
+                "5. End with the signal word (BUY/HOLD/SELL) but with low confidence (≤40%).\n"
+            )
+        return ""
+
+    async def _execute_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> str:
+        """
+        执行本地工具或 MCP 工具（可被子类重写扩展）。
+        实际项目中可将 aria-skills 暴露为工具。
+        """
+        if self.on_tool_start:
+            self.on_tool_start(tool_name, tool_args)
+
+        result = None
+        try:
+            # 路由到数据层或其他 MCP Client 执行
+            if self.data and hasattr(self.data, "execute_tool"):
+                result = await self.data.execute_tool(tool_name, tool_args)
+            else:
+                result = f"Error: Tool {tool_name} not implemented or data router unavailable."
+        except Exception as e:
+            result = f"Error executing {tool_name}: {e}"
+
+        if self.on_tool_end:
+            self.on_tool_end(tool_name, result)
+
+        import json
+        return json.dumps(result, ensure_ascii=False) if not isinstance(result, str) else result
+
+    async def _call_llm(
+        self,
+        system: str,
+        user: str,
+        max_tokens: int = 800,
+        quote: Optional[Dict[str, Any]] = None,
+        max_tool_loops: int = 5,
+    ) -> str:
+        """调用 LLM 生成分析文本，内置 Tool Calling 的执行循环"""
+        if not self.llm:
+            return ""
+        # Inject language rule + time-sensitive fact policy + data guard.
+        _lang_rule = self._LANG_RULES.get(self.lang, self._LANG_RULES["zh"])
+        _data_warn = self._data_guard(quote or {})
+        system = system + self._TIME_SENSITIVE_FACT_POLICY + _lang_rule + _data_warn
+        if self.lang == "en":
+            # The agents' own prompts and much of their data are Chinese. A rule
+            # appended at the end lost to them: an English /team synthesis on
+            # Gemini came back in Chinese. Say it first as well.
+            system = ("Write your entire answer in English, even though the instructions and data "
+                      "below may be in Chinese.\n\n" + system)
+        from aria_code.providers.llm.base import Message
+
+        # 自动注入 DAG pipeline 中的 upstream context
+        if hasattr(self, "_current_data") and self._current_data:
+            upstream = self._current_data.get("upstream_context")
+            if upstream:
+                user += "\n\n## ⬆️ 团队/上游 Agent 提供的背景上下文 (Upstream Insights)\n"
+                user += "请在分析中参考以下来自其他专家 Agent 的核心观点：\n"
+                user += "\n".join(upstream)
+
+        # 融入历史记忆
+        if not self.memory:
+            messages = [
+                Message(role="system", content=system),
+                Message(role="user",   content=user),
+            ]
+        else:
+            messages = list(self.memory)
+            messages.append(Message(role="user", content=user))
+
+        full_text = ""
+        loop_count = 0
+
+        while loop_count < max_tool_loops:
+            loop_count += 1
+            current_text = ""
+            tool_calls = []
+
+            try:
+                async for event in self.llm.stream(
+                    messages, max_tokens=max_tokens
+                ):
+                    t = event.get("type")
+                    if t == "token":
+                        tok = event.get("text", "")
+                        current_text += tok
+                        full_text += tok
+                        if self.on_token:
+                            self.on_token(tok)
+                    elif t == "thought" and self.on_thought:
+                        self.on_thought(event.get("text", ""))
+                    elif t == "tool_call":
+                        # 记录工具调用意图
+                        tool_calls.append({
+                            "name": event.get("name"),
+                            "args": event.get("args", {})
+                        })
+                    elif t == "tool_start" and self.on_tool_start:
+                        self.on_tool_start(event.get("tool_name", ""), event.get("tool_args", {}))
+                    elif t == "tool_end" and self.on_tool_end:
+                        self.on_tool_end(event.get("tool_name", ""), event.get("tool_result", None))
+                    elif t == "error":
+                        # The caller falls back to a template and says so; a
+                        # WARNING here went to the terminal as a raw log line.
+                        self.llm_error = str(event.get("message") or "error")
+                        logger.info(f"[{self.name}] LLM 错误: {event.get('message')}")
+                        break
+            except Exception as e:
+                self.llm_error = str(e) or type(e).__name__
+                logger.info(f"[{self.name}] LLM 调用失败: {e}")
+                break
+
+            # 将当前 Assistant 的回复加入消息流
+            messages.append(Message(role="assistant", content=current_text))
+
+            # 如果没有工具调用，说明 LLM 完成了最终回答，跳出循环
+
+            # If provider didn't emit native tool_calls, fallback to ReAct JSON parsing
+            if not tool_calls:
+                import re
+                import json
+                
+                # Check for explicit JSON tool calls outputted as text
+                matches = re.finditer(r'```json\s*({"type":\s*"tool_call".*?})\s*```', current_text, re.DOTALL)
+                for match in matches:
+                    try:
+                        parsed = json.loads(match.group(1))
+                        tool_calls.append({
+                            "name": parsed.get("name"),
+                            "args": parsed.get("args", {})
+                        })
+                    except Exception as e:
+                        logger.warning(f"Failed to parse ReAct tool call: {e}")
+                
+                # Also check inline unformatted JSON
+                if not tool_calls:
+                    matches_raw = re.finditer(r'{"type":\s*"tool_call",\s*"name":\s*"([^"]+)",\s*"args":\s*({.*?})}', current_text, re.DOTALL)
+                    for match in matches_raw:
+                        try:
+                            args_dict = json.loads(match.group(2))
+                            tool_calls.append({
+                                "name": match.group(1),
+                                "args": args_dict
+                            })
+                        except Exception:
+                            pass
+
+            if not tool_calls:
+                break
+
+
+            # 有工具调用，则逐一执行，并把结果喂回 LLM
+            for tc in tool_calls:
+                tool_res = await self._execute_tool(tc["name"], tc["args"])
+                # 注意：实际 provider 中 Message 结构可能需要 tool_call_id
+                # 这里假设通用 Message 能够携带 role="tool"
+                messages.append(Message(role="tool", name=tc["name"], content=tool_res))
+
+        # 更新短期记忆
+        self.memory = messages
+
+        return full_text.strip()
+
+
+    @abstractmethod
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        核心分析方法。
+
+        Args:
+            symbol: 股票/资产代码
+            data:   由 fetch_data() 预取的数据字典
+
+        Returns:
+            AgentResult
+        """
+        ...
+
+    async def run(self, symbol: str) -> AgentResult:
+        """完整执行：fetch_data → analyze，异常自动捕获。"""
+        try:
+            data   = await self.fetch_data(symbol)
+            result = await self.analyze(symbol, data)
+            return result
+        except Exception as e:
+            logger.error(f"[{self.name}] run({symbol}) 失败: {e}", exc_info=True)
+            return AgentResult(
+                agent=self.name, symbol=symbol,
+                analysis="", confidence=0.0,
+                error=str(e),
+            )
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r})"

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",
+]