aria-code 0.94.0__tar.gz → 0.95.0__tar.gz

{aria_code-0.94.0/src/aria_code.egg-info → aria_code-0.95.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.94.0
+Version: 0.95.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.94.0 → aria_code-0.95.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.94.0"
+version = "0.95.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.94.0"
+__version__ = "0.95.0"

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code/apps/cli/commands/data_cmds.py

@@ -339,23 +339,60 @@ class DataCommandsMixin:
             with self.context.console.status(f"[dim]{ui_text(self, f'获取 {symbol} 同行数据', f'Fetching {symbol} peer data')}...[/dim]", spinner="dots"):
                 from local_finance_tools import _peer_comparison
                 r = await loop.run_in_executor(None, _peer_comparison,
-                                               {"symbol": symbol, "peers": peers})
+                                               {"symbol": symbol, "peers": peers, "lang": ui_text(self, "zh", "en")})
         else:
             from local_finance_tools import _peer_comparison
-            r = _peer_comparison({"symbol": symbol, "peers": peers})
+            r = _peer_comparison({"symbol": symbol, "peers": peers, "lang": ui_text(self, "zh", "en")})
 
         _render_peer_comparison(r)
 
     async def cmd_compare(self, args: str):
-        """多策略横向对比 → /api/v1/backtest/compare-strategies"""
-        parts = args.split() if args else ["SPY"]
-        symbol = parts[0].upper() if parts else "SPY"
-        start = parts[1] if len(parts) > 1 else "2020-01-01"
-        end = parts[2] if len(parts) > 2 else __import__("datetime").date.today().isoformat()
+        """/compare SYMBOL [start] [end] — several strategies on one symbol, against buy-and-hold.
+
+        /compare AAPL MSFT read MSFT as the start date, and the local fallback
+        ran four of its five strategies as buy-and-hold (the local engine had
+        no such names and fell through to it), so the table showed four
+        identical rows. Its "start → end" title was the dates asked for, not
+        the ones used, and the Buy & Hold row was a total return in the
+        annual-return column with a made-up trade count.
+        """
+        import re as _re
+
+        parts = args.split() if args and args.strip() else ["SPY"]
+        symbol = parts[0].upper()
+        rest = parts[1:]
+        def is_date(token: str) -> bool:
+            # A real date: 2024-13-01 has the shape and reached yfinance, whose
+            # failure was then explained as rate limiting.
+            try:
+                __import__("datetime").date.fromisoformat(token)
+                return len(token) == 10
+            except ValueError:
+                return False
+        if rest and not is_date(rest[0]):
+            # A symbol has a letter (AAPL, 0700.HK) or is a six-digit A-share code.
+            if all(_re.fullmatch(r"(?=.*[A-Za-z])[A-Za-z0-9.^=-]{1,12}|\d{6}", t) for t in rest):
+                # Two or more symbols: the user is comparing stocks, which is /peer.
+                peers = " ".join(t.upper() for t in rest)
+                note = f"→ /peer {symbol} {peers}"
+                self.context.console.print(f"  [dim]{note}[/dim]") if self.context.has_rich else print(f"  {note}")
+                await self.cmd_peer(f"{symbol} {peers}")
+                return
+            print_error(self.context, ui_text(self, f"无法识别的日期：{rest[0]}", f"Not a date: {rest[0]}"),
+                        "Usage: /compare SYMBOL [YYYY-MM-DD] [YYYY-MM-DD]")
+            return
+        if len(rest) > 1 and not is_date(rest[1]):
+            print_error(self.context, ui_text(self, f"无法识别的日期：{rest[1]}", f"Not a date: {rest[1]}"),
+                        "Usage: /compare SYMBOL [YYYY-MM-DD] [YYYY-MM-DD]")
+            return
+        start = rest[0] if rest else "2020-01-01"
+        end = rest[1] if len(rest) > 1 else __import__("datetime").date.today().isoformat()
         api_url = self.terminal.config.get("api_url", "http://localhost:8000")
         import aiohttp
 
         _STRATS = ["momentum", "mean_reversion", "breakout", "turtle", "ma_crossover"]
+        # What the local engine can run, under the names /compare shows.
+        _LOCAL = {"momentum": "momentum", "mean_reversion": "rsi_mean_revert", "ma_crossover": "sma_cross"}
 
         async def _do():
             payload = {"symbol": symbol, "strategies": _STRATS,
@@ -367,76 +404,90 @@ class DataCommandsMixin:
                     body = await resp.json()
                     return body.get("data", body)
 
+        def _row(name: str, d: dict) -> dict:
+            ann = float(d.get("annual_return", 0) or 0)
+            mdd = float(d.get("max_drawdown", 0) or 0)
+            return {
+                "name": name,
+                "annualized_return_pct": ann * 100,
+                "sharpe_ratio": float(d.get("sharpe_ratio", 0) or 0),
+                "max_drawdown_pct": mdd * 100,
+                "calmar_ratio": (ann / abs(mdd)) if mdd else 0.0,
+                "sortino_ratio": float(d.get("sortino_ratio", 0) or 0),
+                "win_rate_pct": float(d.get("win_rate", 0) or 0) * 100,
+                "n_trades": int(d.get("total_trades", 0) or 0),
+            }
+
         def _do_local():
-            """Fallback: run each strategy via the local backtest engine and
-            assemble the same shape the backend endpoint returns. Used when the
-            backend is down or lacks the compare-strategies endpoint."""
-            import asyncio as _aio
-            rows = []
-            bench_pct = 0.0
-            for strat in _STRATS:
+            """The strategies the local engine has, over the same dates, and
+            buy-and-hold run through the same engine as the benchmark."""
+            run = _get_LOCAL_TOOLS()["backtest_strategy"][0]
+            rows, period, errors = [], None, []
+            for shown, local in _LOCAL.items():
                 try:
-                    res = _get_LOCAL_TOOLS()["backtest_strategy"][0](
-                        {"symbol": symbol, "strategy": strat})
-                except Exception:
+                    res = run({"symbol": symbol, "strategy": local, "start": start, "end": end})
+                except Exception as exc:
+                    errors.append(f"{shown}: {exc}")
                     continue
                 if not res.get("success"):
+                    errors.append(f"{shown}: {res.get('error', 'failed')}")
                     continue
                 d = res.get("data", res)
-                ann = float(d.get("annual_return", 0) or 0)
-                mdd = float(d.get("max_drawdown", 0) or 0)
-                calmar = (ann / abs(mdd)) if mdd else 0.0
-                rows.append({
-                    "name": strat,
-                    "annualized_return_pct": ann * 100,
-                    "sharpe_ratio": float(d.get("sharpe_ratio", 0) or 0),
-                    "max_drawdown_pct": mdd * 100,
-                    "calmar_ratio": calmar,
-                    "sortino_ratio": float(d.get("sortino_ratio", 0) or 0),
-                    "win_rate_pct": float(d.get("win_rate", 0) or 0) * 100,
-                    "n_trades": int(d.get("total_trades", 0) or 0),
-                })
-                br = d.get("benchmark_return")
-                if br is not None and br == br:  # not NaN
-                    bench_pct = float(br) * 100
+                period = period or (d.get("start"), d.get("end"))
+                rows.append(_row(shown, d))
             rows.sort(key=lambda r: r["sharpe_ratio"], reverse=True)
             for i, r in enumerate(rows, 1):
                 r["rank_by_sharpe"] = i
-            return {"strategies": rows, "benchmark": {"annualized_return_pct": bench_pct},
-                    "provider": "local"}
+            bench = {}
+            try:
+                b = run({"symbol": symbol, "strategy": "buy_hold", "start": start, "end": end})
+                if b.get("success"):
+                    bench = _row("buy_hold", b.get("data", b))
+            except Exception:
+                pass
+            return {"strategies": rows, "benchmark": bench, "provider": "local", "period": period,
+                    "skipped": [s for s in _STRATS if s not in _LOCAL], "errors": errors}
 
         async def _do_with_fallback():
             try:
                 return await _do()
             except Exception:
                 # Backend unavailable / missing endpoint → local engine
+                note = ui_text(self, "后端不可用，使用本地回测引擎对比…",
+                               "Backend unavailable; comparing with the local backtest engine…")
                 if self.context.has_rich:
-                    self.context.console.print("  [dim]后端不可用，使用本地回测引擎对比…[/dim]")
-                return _do_local()
+                    self.context.console.print(f"  [dim]{note}[/dim]")
+                import asyncio as _aio
+                return await _aio.get_event_loop().run_in_executor(None, _do_local)
 
+        status = ui_text(self, f"正在对比 {symbol} 的策略", f"Comparing strategies on {symbol}")
         if self.context.has_rich:
-            with self.context.console.status(f"[dim]Comparing strategies on {symbol}...[/dim]", spinner="dots"):
+            with self.context.console.status(f"[dim]{status}...[/dim]", spinner="dots"):
                 try:
                     data = await _do_with_fallback()
                 except Exception as e:
                     print_error(self.context, str(e), "tool")
                     return
         else:
-            print(f"Comparing strategies on {symbol}...")
+            print(f"{status}...")
             try:
                 data = await _do_with_fallback()
             except Exception as e:
                 print_error(self.context, str(e), "tool")
                 return
         if not data.get("strategies"):
-            print_error(self.context, "策略对比无结果", "本地回测引擎未返回数据，检查标的代码是否正确")
+            detail = "; ".join(data.get("errors") or []) or ui_text(
+                self, "检查标的代码和日期是否正确", "check the symbol and the dates")
+            print_error(self.context, ui_text(self, "策略对比无结果", "No strategy results"), detail)
             return
 
         strategies = data.get("strategies", [])
-        bh = data.get("benchmark", {})
+        bh = data.get("benchmark", {}) or {}
+        period = data.get("period") or (start, end)
         if self.context.has_rich:
             from rich.table import Table
-            tbl = Table(title=f"[bold]{symbol} Strategy Comparison[/bold]  {start} → {end}", show_header=True, header_style="bold")
+            tbl = Table(title=f"[bold]{symbol} Strategy Comparison[/bold]  {period[0]} → {period[1]}",
+                        show_header=True, header_style="bold")
             for col in ["Rank", "Strategy", "Ann.Ret%", "Sharpe", "MaxDD%", "Calmar", "Sortino", "Win%", "Trades"]:
                 tbl.add_column(col, justify="right")
             for s in strategies:
@@ -451,11 +502,20 @@ class DataCommandsMixin:
                     f"{s.get('win_rate_pct',0):.0f}%",
                     str(s.get("n_trades",0)),
                 )
-            tbl.add_row("—", "[dim]Buy & Hold[/dim]",
-                        f"{bh.get('annualized_return_pct',0):+.1f}%",
-                        f"{bh.get('sharpe_ratio',0):.3f}",
-                        f"{bh.get('max_drawdown_pct',0):.1f}%", "—", "—", "—", "2")
+            if bh:
+                tbl.add_row("—", "[dim]Buy & Hold[/dim]",
+                            f"{bh.get('annualized_return_pct',0):+.1f}%",
+                            f"{bh.get('sharpe_ratio',0):.3f}",
+                            f"{bh.get('max_drawdown_pct',0):.1f}%",
+                            f"{bh['calmar_ratio']:.2f}" if "calmar_ratio" in bh else "—",
+                            f"{bh['sortino_ratio']:.2f}" if "sortino_ratio" in bh else "—",
+                            "—", str(bh["n_trades"]) if "n_trades" in bh else "—")
             self.context.console.print(tbl)
+            if data.get("skipped"):
+                self.context.console.print("  [dim]" + ui_text(
+                    self, f"本地引擎没有 {', '.join(data['skipped'])}，需后端才能对比。",
+                    f"{', '.join(data['skipped'])} need the backend; the local engine does not have them.")
+                    + "[/dim]")
         else:
             for s in strategies:
                 print(f"{s['name']}: Ann={s.get('annualized_return_pct',0):+.1f}% Sharpe={s.get('sharpe_ratio',0):.2f} DD={s.get('max_drawdown_pct',0):.1f}%")

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code/apps/cli/handlers/chart_handlers.py

@@ -672,7 +672,12 @@ def handle_stock_chart_analysis_direct(symbol: str, period: str = "1y") -> dict:
     pe         = info.get("trailingPE")
     pb         = info.get("priceToBook")
     roe        = info.get("returnOnEquity")
-    div_yield  = info.get("trailingAnnualDividendYield") or info.get("dividendYield")
+    # A fraction, as _fv(div_yield, 100, pct=True) below expects. The fallback
+    # was dividendYield, which yfinance gives already in percent: 100x too big.
+    trailing   = info.get("trailingAnnualDividendYield")
+    rate       = info.get("dividendRate")
+    price_now  = info.get("regularMarketPrice") or info.get("currentPrice")
+    div_yield  = trailing or (float(rate) / float(price_now) if rate and price_now else None)
     market_cap = info.get("marketCap")
 
     def _fv(v, mult=1.0, pct=False):

aria_code-0.95.0/src/aria_code/apps/cli/workspace_route.py

@@ -0,0 +1,95 @@
+"""A task about this folder, sent to a model that cannot touch it.
+
+With backend_chat on, turns go to the Arthera backend, which receives the
+prompt and history but none of Aria's local tools. Asked to run
+`python3 -c 'import calc; print(calc.add(2,3))'` in a folder, it said it had
+no filesystem access and gave the output as 5; the function subtracts, so it
+is -1. The turn reported success with no tools used, and `-p` exited 0. A
+small local model without tool calling is in the same position.
+
+``needs_workspace`` asks only whether a message needs this machine: it names
+a file or imports a module that exists here, uses an @file reference, asks
+for a command to be run, or says "this project", "the failing tests" and the
+like. A question about code in general ("explain Python decorators") does not
+need the folder and is left alone.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_PATH_TOKEN = re.compile(r"[\w./-]+\.[A-Za-z0-9]{1,6}\b|[\w-]+/[\w./-]+")
+_HERE_EN = re.compile(
+    r"\b(?:this|my|our|current)\s+(?:project|repo|repository|folder|directory|codebase|workspace|"
+    r"working\s+tree)\b|\bin\s+here\b|\b(?:the\s+)?failing\s+tests?\b|\bmy\s+(?:code|tests)\b",
+    re.I,
+)
+# Asking for a command to be run needs a tool to run it, wherever it points.
+_RUN_EN = re.compile(r"\b(?:run|execute)\s+(?:`|python3?\b|pytest\b|npm\b|npx\b|node\b|make\b|cargo\b|"
+                     r"go\s+(?:test|run|build)\b|bash\b|sh\b|pip3?\b|uv\b|git\b|ls\b|the\s+tests?\b)", re.I)
+_RUN_ZH = re.compile(r"(?:运行|执行|跑一下|跑)\s*(?:`|python|pytest|npm|node|git|make|命令|脚本|测试)", re.I)
+_IMPORT = re.compile(r"\b(?:import|from)\s+([A-Za-z_]\w*)")
+_HERE_ZH = ("这个项目", "该项目", "当前项目", "这个仓库", "当前仓库", "这个目录", "当前目录", "这个文件夹",
+            "当前文件夹", "这个代码库", "本项目", "本仓库", "失败的测试", "我的代码")
+
+
+def needs_workspace(text: str, cwd: Path | str | None = None) -> bool:
+    """True when the message is about files in ``cwd`` (default: the current directory)."""
+    message = str(text or "")
+    if "@file:" in message or "@folder:" in message:
+        return True
+    if _HERE_EN.search(message) or any(word in message for word in _HERE_ZH):
+        return True
+    if _RUN_EN.search(message) or _RUN_ZH.search(message):
+        return True
+    base = Path(cwd or Path.cwd())
+    for module in _IMPORT.findall(message):
+        if (base / f"{module}.py").is_file() or (base / module / "__init__.py").is_file():
+            return True
+    for token in _PATH_TOKEN.findall(message):
+        candidate = token.strip("./") if token.startswith("./") else token
+        try:
+            if candidate and (base / candidate).exists():
+                return True
+        except (OSError, ValueError):
+            continue
+    return False
+
+
+def route_has_tools(model: str, config: dict, api_url: str | None) -> bool:
+    """Whether this turn's model can call Aria's local tools."""
+    try:
+        from aria_code.model_capability import get_model_capability
+
+        capability = get_model_capability(model)
+        if not (capability.tool_calls and capability.context_window >= 8192):
+            return False
+    except Exception:
+        pass
+    try:
+        from aria_code.apps.cli.providers.chat_routing import model_receives_local_tools
+
+        return model_receives_local_tools(model, config, api_url)
+    except Exception:
+        return True
+
+
+def no_tools_message(config: dict, *, lang: str = "en") -> str:
+    """Why the model cannot do this here, and what to change."""
+    backend = bool(config.get("backend_chat"))
+    if lang == "zh":
+        why = ("当前通过 Arthera 云端对话（backend_chat），那里的模型读不到这个文件夹，也不能运行命令"
+               if backend else "当前模型不支持工具调用，读不到这个文件夹，也不能运行命令")
+        return (f"{why}，关于这里文件的回答只能是推测。要在这个文件夹里写代码、跑测试，请用 /model "
+                "选一个能调用工具的模型（例如 Vertex 上的 Gemini、OpenAI 或 Ollama 的 qwen2.5-coder），"
+                "或用 aria-code --local。")
+    why = ("Turns go to Arthera cloud chat (backend_chat), where the model cannot read this folder or run "
+           "commands" if backend else "The current model cannot call tools, so it cannot read this folder "
+           "or run commands")
+    return (f"{why}; anything it says about files here is a guess. To work on code in this folder, pick a "
+            "model that runs tools with /model (Gemini on Vertex, OpenAI, or an Ollama model such as "
+            "qwen2.5-coder), or start with aria-code --local.")
+
+
+__all__ = ["needs_workspace", "route_has_tools", "no_tools_message"]

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code/aria_cli.py

@@ -5133,6 +5133,21 @@ class ArtheraTerminal:
                 console.print(f"[{_agent_color}]{_agent_name}[/{_agent_color}]{_answer_meta}")
             else:
                 print(f"{_agent_name}{' · ' + _answer_model if _answer_model else ''}")
+        # A task about this folder on a model that cannot open it gets a guess
+        # that reads like a result (backend_chat answered "5" for a function
+        # that returns -1). Say so before the answer, once a session; the
+        # person can still read it, and knows what it is.
+        if not _model_has_tools and not getattr(self, "_no_tools_notice_shown", False):
+            from apps.cli.workspace_route import needs_workspace, no_tools_message
+            if needs_workspace(message):
+                self._no_tools_notice_shown = True
+                _zh_nt = str(self.config.get("ui_lang", "en")).lower().startswith("zh")
+                _why = no_tools_message(self.config, lang="zh" if _zh_nt else "en")
+                if HAS_RICH:
+                    from aria_code.ui.render.output import print_hanging
+                    print_hanging(console, "  ! ", _why, style="yellow")
+                else:
+                    print(f"  ! {_why}")
         # ── Single-shot turn through the shared runtime Gateway ─────────────
         # The per-round inline agent loop that used to live here was removed
         # (2026-07) after the runtime path was validated with real turns:
@@ -6523,13 +6538,11 @@ class ArtheraTerminal:
         self._maybe_show_intent_preflight(prompt, quiet=quiet)
 
         _curr_model_id_p = self.config.get("model", "")
-        _model_has_tools_p = False
-        if _HAS_MODEL_CAP:
-            try:
-                _mc_p = get_model_capability(_curr_model_id_p)
-                _model_has_tools_p = bool(_mc_p.tool_calls and _mc_p.context_window >= 8192)
-            except Exception:
-                pass
+        # The route counts as much as the model: on backend_chat the model gets
+        # no local tools whatever it could do with them. This only looked at the
+        # model, so the deterministic chain skipped its data pre-fetch there.
+        from aria_code.apps.cli.workspace_route import no_tools_message, needs_workspace, route_has_tools
+        _model_has_tools_p = route_has_tools(_curr_model_id_p, self.config, self.api_url)
 
         # ── Broker guide intent: broad discovery should not start an add wizard ──
         if _is_broker_guide_intent(prompt):
@@ -6560,6 +6573,14 @@ class ArtheraTerminal:
         if deterministic.get("success") or _is_stock_chart_analysis_request(prompt):
             result = deterministic
         else:
+            # No one reads a headless answer before a script acts on it. A task
+            # about this folder on a model that cannot open it would come back as
+            # a confident guess with exit 0; fail before sending it instead.
+            if not _model_has_tools_p and needs_workspace(prompt):
+                _zh = str(self.config.get("ui_lang", "en")).lower().startswith("zh")
+                _why = no_tools_message(self.config, lang="zh" if _zh else "en")
+                print(_why, file=sys.stderr)
+                return {"success": False, "response": "", "error": "model_cannot_use_tools", "detail": _why}
             # Spinner for terminal usage: gives visual feedback while the model generates.
             # Only starts when we actually need to call the LLM (not for deterministic responses).
             _prompt_spinner = None

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code/tools/local_finance_tools.py

@@ -559,6 +559,15 @@ def _calculate_factors(params: dict) -> dict:
 # 5. backtest_strategy
 # ---------------------------------------------------------------------------
 
+# Every name the local engine accepts, mapped to the strategy it runs.
+_LOCAL_STRATEGIES = {
+    "sma_cross": "sma_cross", "ma_cross": "sma_cross", "ma_crossover": "sma_cross", "sma": "sma_cross",
+    "rsi_mean_revert": "rsi_mean_revert", "rsi": "rsi_mean_revert", "mean_reversion": "rsi_mean_revert",
+    "momentum": "momentum", "mom": "momentum",
+    "buy_hold": "buy_hold", "buy_and_hold": "buy_hold", "bh": "buy_hold",
+}
+
+
 def _backtest_strategy(params: dict) -> dict:
     """
     Simple backtest engine.  Supports:
@@ -566,6 +575,15 @@ def _backtest_strategy(params: dict) -> dict:
     """
     symbol   = params.get("symbol", "AAPL")
     strategy = params.get("strategy", "sma_cross").lower().replace(" ", "_").replace("-", "_")
+    # An unknown name used to fall through to buy-and-hold and report its
+    # numbers under the name asked for: /compare showed mean_reversion,
+    # breakout, turtle and ma_crossover with identical results, all of them
+    # buy-and-hold.
+    known = _LOCAL_STRATEGIES.get(strategy)
+    if known is None:
+        return {"success": False, "error": f"Unknown strategy '{strategy}'. The local engine runs: "
+                                           + ", ".join(sorted(set(_LOCAL_STRATEGIES.values())))}
+    strategy = known
     start    = params.get("start", _parse_date(None, 3 * 365))
     end      = params.get("end", _today())
     fast     = int(params.get("fast_period", 20))
@@ -598,12 +616,12 @@ def _backtest_strategy(params: dict) -> dict:
     close = df["Close"].astype(float)
 
     # ── Signal generation ─────────────────────────────────────────────────
-    if strategy in ("sma_cross", "ma_cross"):
+    if strategy == "sma_cross":
         ma_f = close.rolling(fast).mean()
         ma_s = close.rolling(slow).mean()
         signal = (ma_f > ma_s).astype(int)
 
-    elif strategy in ("rsi_mean_revert", "rsi"):
+    elif strategy == "rsi_mean_revert":
         delta = close.diff()
         gain  = delta.clip(lower=0).rolling(14).mean()
         loss  = (-delta.clip(upper=0)).rolling(14).mean()
@@ -2955,6 +2973,24 @@ def _walk_forward_backtest(params: dict) -> dict:
 # 25. Peer Comparison  (同行对比)
 # ---------------------------------------------------------------------------
 
+def _dividend_yield_pct(info: dict):
+    """Dividend yield in percent from a yfinance info dict, or None.
+
+    yfinance's ``dividendYield`` is already a percentage (0.32 for AAPL's
+    0.32%); multiplied by 100 again it showed AAPL at 32% and MSFT at 75%.
+    ``trailingAnnualDividendYield`` is a fraction, and rate / price needs no
+    knowledge of either.
+    """
+    trailing = info.get("trailingAnnualDividendYield")
+    if trailing:
+        return float(trailing) * 100
+    rate = info.get("dividendRate") or info.get("trailingAnnualDividendRate")
+    price = info.get("regularMarketPrice") or info.get("currentPrice") or info.get("previousClose")
+    if rate and price:
+        return float(rate) / float(price) * 100
+    return None
+
+
 def _peer_comparison(params: dict) -> dict:
     """
     同行估值与表现对比。
@@ -3000,7 +3036,7 @@ def _peer_comparison(params: dict) -> dict:
             pe     = info.get("trailingPE") or info.get("forwardPE")
             pb     = info.get("priceToBook")
             roe    = info.get("returnOnEquity")
-            dy     = info.get("dividendYield")
+            dy     = _dividend_yield_pct(info)
             mc     = info.get("marketCap")
             ytd    = (price / prev - 1) if prev else None
             rows.append({
@@ -3010,7 +3046,7 @@ def _peer_comparison(params: dict) -> dict:
                 "pe":        round(pe, 1)  if pe  else None,
                 "pb":        round(pb, 2)  if pb  else None,
                 "roe_pct":   round(roe * 100, 1) if roe else None,
-                "div_yield": round(dy * 100, 2)  if dy  else None,
+                "div_yield": round(dy, 2)        if dy  else None,
                 "market_cap_b": round(mc / 1e9, 1) if mc else None,
                 "is_target": sym == symbol,
             })
@@ -3021,20 +3057,39 @@ def _peer_comparison(params: dict) -> dict:
         return {"success": False, "error": "无法获取对比数据"}
 
     # Relative rankings
-    pe_vals  = [r["pe"]   for r in rows if r["pe"] is not None]
-    pb_vals  = [r["pb"]   for r in rows if r["pb"] is not None]
-    roe_vals = [r["roe_pct"] for r in rows if r["roe_pct"] is not None]
-
     target_row = next((r for r in rows if r["is_target"]), rows[0])
+    # The peers only. The target was counted among its own peers, so with one
+    # peer the "peer median" PE was the target's own PE and the verdict was
+    # always "fair"; the ROE average was half the target's.
+    others   = [r for r in rows if r is not target_row]
+    pe_vals  = [r["pe"] for r in others if r["pe"] is not None]
+    roe_vals = [r["roe_pct"] for r in others if r["roe_pct"] is not None]
+    zh = str(params.get("lang", "zh")).lower().startswith("zh")
+
+    def _median(values):
+        ordered = sorted(values)
+        mid = len(ordered) // 2
+        return ordered[mid] if len(ordered) % 2 else (ordered[mid - 1] + ordered[mid]) / 2
+
     analysis = []
     if target_row.get("pe") and pe_vals:
-        med_pe = sorted(pe_vals)[len(pe_vals)//2]
-        vs = "高估" if target_row["pe"] > med_pe * 1.2 else "低估" if target_row["pe"] < med_pe * 0.8 else "合理"
-        analysis.append(f"PE {target_row['pe']:.1f}x vs 同行中位数 {med_pe:.1f}x → {vs}")
+        med_pe = _median(pe_vals)
+        high, low = target_row["pe"] > med_pe * 1.2, target_row["pe"] < med_pe * 0.8
+        if zh:
+            vs = "高估" if high else "低估" if low else "合理"
+            analysis.append(f"PE {target_row['pe']:.1f}x vs 同行中位数 {med_pe:.1f}x → {vs}")
+        else:
+            vs = "above peers" if high else "below peers" if low else "in line"
+            analysis.append(f"PE {target_row['pe']:.1f}x vs peer median {med_pe:.1f}x → {vs}")
     if target_row.get("roe_pct") and roe_vals:
         avg_roe = sum(roe_vals) / len(roe_vals)
-        vs = "优于同行" if target_row["roe_pct"] > avg_roe else "低于同行"
-        analysis.append(f"ROE {target_row['roe_pct']:.1f}% vs 同行均值 {avg_roe:.1f}% → {vs}")
+        better = target_row["roe_pct"] > avg_roe
+        if zh:
+            analysis.append(f"ROE {target_row['roe_pct']:.1f}% vs 同行均值 {avg_roe:.1f}% → "
+                            f"{'优于同行' if better else '低于同行'}")
+        else:
+            analysis.append(f"ROE {target_row['roe_pct']:.1f}% vs peer average {avg_roe:.1f}% → "
+                            f"{'above peers' if better else 'below peers'}")
 
     return {
         "success":   True,
@@ -3042,6 +3097,7 @@ def _peer_comparison(params: dict) -> dict:
         "peers":     peers,
         "table":     rows,
         "analysis":  analysis,
+        "lang":      "zh" if zh else "en",
         "provider":  "yfinance",
     }
 

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code/ui/render/finance.py

@@ -1309,15 +1309,16 @@ def render_peer_comparison(r: dict, *, console=None, has_rich: bool = True) -> N
         from rich.table import Table
         from rich.rule import Rule
         symbol = r.get("symbol","")
-        console.print(Rule(f"[bold]{symbol}[/bold] 同行估值对比", style="dim"))
+        zh = str(r.get("lang", "zh")).lower().startswith("zh")
+        console.print(Rule(f"[bold]{symbol}[/bold] " + ("同行估值对比" if zh else "peer valuation"), style="dim"))
         t = Table(show_header=True, box=None, padding=(0,1))
-        t.add_column("代码",      style="bold",  width=8)
-        t.add_column("名称",      width=14)
+        t.add_column("代码" if zh else "Symbol", style="bold",  width=8)
+        t.add_column("名称" if zh else "Name",   width=14)
         t.add_column("PE",        justify="right")
         t.add_column("PB",        justify="right")
         t.add_column("ROE%",      justify="right")
-        t.add_column("股息%",     justify="right")
-        t.add_column("市值(B)",   justify="right", style="dim")
+        t.add_column("股息%" if zh else "Div%",   justify="right")
+        t.add_column("市值(B)" if zh else "Mkt cap (B)", justify="right", style="dim")
         for row in rows:
             is_t = row.get("is_target", False)
             pe   = f"{row['pe']:.1f}" if row.get("pe") else "—"
@@ -1337,7 +1338,8 @@ def render_peer_comparison(r: dict, *, console=None, has_rich: bool = True) -> N
         for line in analysis:
             console.print(f"  [dim]▸ {line}[/dim]")
     else:
-        print(f"\n{r.get('symbol','')} 同行对比")
+        zh = str(r.get("lang", "zh")).lower().startswith("zh")
+        print(f"\n{r.get('symbol','')} " + ("同行对比" if zh else "peer comparison"))
         for row in rows:
             print(f"  {row['symbol']:<8} PE:{row.get('pe','—')} PB:{row.get('pb','—')}")
 

{aria_code-0.94.0 → aria_code-0.95.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.94.0
+Version: 0.95.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.94.0 → aria_code-0.95.0}/src/aria_code.egg-info/SOURCES.txt

@@ -205,6 +205,7 @@ src/aria_code/apps/cli/tradingview_bridge.py
 src/aria_code/apps/cli/turn_planning.py
 src/aria_code/apps/cli/update_check.py
 src/aria_code/apps/cli/updater.py
+src/aria_code/apps/cli/workspace_route.py
 src/aria_code/apps/cli/commands/__init__.py
 src/aria_code/apps/cli/commands/_business_render.py
 src/aria_code/apps/cli/commands/_ui.py
@@ -546,6 +547,7 @@ tests/test_coder_tool_safety.py
 tests/test_collaboration.py
 tests/test_command_loggers.py
 tests/test_command_safety.py
+tests/test_compare_strategies.py
 tests/test_completions_builder.py
 tests/test_config_paths.py
 tests/test_configured_provider.py
@@ -628,6 +630,7 @@ tests/test_native_installer.py
 tests/test_natural_language_routing.py
 tests/test_new_modules.py
 tests/test_no_hardcoded_developer_paths.py
+tests/test_no_tools_route.py
 tests/test_no_uncommitted_imports.py
 tests/test_numeric_listings.py
 tests/test_ollama_stream_imports.py