aria-code 0.52.0__py3-none-any.whl

aria_code/__init__.py

@@ -0,0 +1,42 @@
+"""Aria Code.
+
+This package is importable under two roots by design, and has been since the
+src/ restructure: ``aria_code.X`` and a bare ``X``. The tree uses both — 399
+modules import each other bare (``from market_data_client import get_mdc``)
+while others use the package path, and the tests patch whichever root the code
+under test actually uses. tests/test_single_import_root.py exists to keep a
+single *file* from mixing the two.
+
+In development both roots resolve because pyproject's
+``pythonpath = [".", "src", "src/aria_code"]`` and tests/conftest.py put them
+there. An installed wheel has neither, so only ``aria_code`` resolved and the
+console script died immediately:
+
+    $ aria-code --version
+    ModuleNotFoundError: No module named 'aria_cli'
+
+4.4.1 did not hit this because its wheel predates the restructure — it shipped
+``aria_cli.py`` and 56 other modules at top level, so the bare root *was* the
+package. After the move, nothing put the inner directory on the path.
+
+Adding it here rather than shipping a .pth file keeps it inside the package, so
+it applies to `pip install`, `pip install -e .`, a zipapp and a PyInstaller
+bundle alike, and it is visible to anyone reading the package rather than hidden
+in site-packages.
+
+This is a bridge, not the destination. One root is the goal — v4.4.2 converted
+the tree to ``aria_code.*`` throughout — but converting it means moving every
+test's patch target with it, and doing that silently under a release is how the
+bare-root bugs in this history were introduced.
+"""
+
+import os as _os
+import sys as _sys
+
+_HERE = _os.path.dirname(_os.path.abspath(__file__))
+if _HERE not in _sys.path:
+    # Appended, not inserted: a module that legitimately shadows one of these
+    # names in the user's own project must keep winning.
+    _sys.path.append(_HERE)
+
+del _os, _sys, _HERE

aria_code/_version.py

@@ -0,0 +1,20 @@
+"""Single source of truth for the package version.
+
+__version__ used to live in aria_cli.py, which meant anything wanting the
+version string had to import the whole interactive CLI — prompt_toolkit,
+bootstrap hooks, the tool registry, all of it. The three consumers each worked
+around that differently: crash_report and a diagnostics accessor imported
+aria_cli anyway, and the MCP server went to importlib.metadata instead, with a
+comment explaining that pulling in aria_cli was too heavy for a binary whose
+job is speaking JSON-RPC over stdio.
+
+Keeping it here costs nothing to import and gives all three the same answer.
+Note that importlib.metadata reports what was *installed*, which is not the
+same thing when running from a source checkout.
+"""
+
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "0.52.0"

aria_code/adk_apps/__init__.py

@@ -0,0 +1 @@
+"""ADK application packages shipped as optional Aria Code integrations."""

aria_code/adk_apps/aria_code_review/__init__.py

@@ -0,0 +1 @@
+"""Google ADK entrypoint package for Aria's read-only code reviewer."""

aria_code/adk_apps/aria_code_review/agent.py

@@ -0,0 +1,32 @@
+"""Google ADK entrypoint: a bounded reviewer for pasted code."""
+
+from __future__ import annotations
+
+import os
+
+from google.adk.agents.llm_agent import Agent
+
+from aria_code.packages.adk_bridge import CodeReviewTools
+
+
+_tools = CodeReviewTools()
+
+root_agent = Agent(
+    model=os.getenv("ARIA_ADK_MODEL", "gemini-3.5-flash"),
+    name="aria_code_review",
+    description="A read-only code reviewer for user-submitted source text.",
+    instruction="""You are Aria Code Review, a careful software reviewer.
+
+Ask the user to paste the relevant source code when it has not been supplied.
+Use review_code for deterministic findings and preserve its severity, line,
+rule, and limitations. Never claim to have opened a local path, accessed a
+repository, run a command, changed a file, or executed tests: this ADK agent
+has none of those capabilities.
+
+Explain only findings supported by the submitted code. Separate deterministic
+findings from suggestions, and recommend a test or validation step where
+appropriate. Do not expose credentials appearing in source; tell the user to
+revoke and rotate any exposed credential instead.
+""",
+    tools=[_tools.review_code],
+)

aria_code/adk_apps/aria_research/__init__.py

@@ -0,0 +1 @@
+"""Read-only Aria market-research agent for Google ADK."""

aria_code/adk_apps/aria_research/agent.py

@@ -0,0 +1,31 @@
+"""Google ADK entrypoint: ``adk web adk_apps`` discovers ``aria_research``."""
+
+from __future__ import annotations
+
+import os
+
+from google.adk.agents.llm_agent import Agent
+
+from aria_code.packages.adk_bridge import MarketResearchTools
+
+
+_tools = MarketResearchTools()
+
+root_agent = Agent(
+    model=os.getenv("ARIA_ADK_MODEL", "gemini-3.5-flash"),
+    name="aria_research",
+    description="A read-only market-research assistant for Aria Code and Arthera.",
+    instruction="""You are Aria Research, a careful financial-research assistant.
+
+Use get_market_snapshot for live market facts and explicitly identify its data
+quality, timestamp, warnings, and source limitations. Use get_market_data_health
+when a data result is missing, stale, or conflicting. Do not invent prices,
+returns, news, citations, positions, or tool output.
+
+This agent is research-only. Never claim to execute, recommend, place, modify,
+or schedule trades. Do not request credentials. State clearly that your output
+is research assistance, not investment advice. For quantitative conclusions,
+separate observed facts from hypotheses and mention material uncertainty.
+""",
+    tools=[_tools.get_market_snapshot, _tools.get_market_data_health],
+)

aria_code/agents/__init__.py

@@ -0,0 +1,34 @@
+"""
+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:
+            ...
+"""
+
+from .base import BaseAgent, AgentResult
+from .registry import AgentRegistry, get_registry
+from .team import AgentTeam, run_team
+from .signal_scheme import SignalScheme, FINANCIAL_SCHEME, REALTY_SCHEME
+
+__all__ = [
+    "BaseAgent", "AgentResult",
+    "AgentRegistry", "get_registry",
+    "AgentTeam", "run_team",
+    "SignalScheme", "FINANCIAL_SCHEME", "REALTY_SCHEME",
+]

aria_code/agents/base.py

@@ -0,0 +1,318 @@
+"""
+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.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
+        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":
+                        logger.warning(f"[{self.name}] LLM 错误: {event.get('message')}")
+                        break
+            except Exception as e:
+                logger.warning(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})"