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

{aria_code-0.93.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.93.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
@@ -251,6 +251,12 @@ aria-code -p "Inspect this project, fix the failing tests, run them, and summari
 
 Aria may request approval before editing files or running commands, according to the configured permission mode. Review changes and test results before committing them.
 
+In a script or CI job, `--json` prints one JSON result and `--format jsonl` prints one JSON event per line as the turn runs (`turn.started`, `tool.started`, `tool.completed`, `turn.completed`). Only JSON goes to stdout, and a failed turn exits 1. With no one there to approve, pass `--allow-tools edit_file,run_command` for the tools the job may use.
+
+```bash
+aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools edit_file,run_command > events.jsonl
+```
+
 ## Models and accounts
 
 | Route | What it needs |

{aria_code-0.93.0 → aria_code-0.95.0}/README.md

@@ -95,6 +95,12 @@ aria-code -p "Inspect this project, fix the failing tests, run them, and summari
 
 Aria may request approval before editing files or running commands, according to the configured permission mode. Review changes and test results before committing them.
 
+In a script or CI job, `--json` prints one JSON result and `--format jsonl` prints one JSON event per line as the turn runs (`turn.started`, `tool.started`, `tool.completed`, `turn.completed`). Only JSON goes to stdout, and a failed turn exits 1. With no one there to approve, pass `--allow-tools edit_file,run_command` for the tools the job may use.
+
+```bash
+aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools edit_file,run_command > events.jsonl
+```
+
 ## Models and accounts
 
 | Route | What it needs |

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.93.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.93.0 → aria_code-0.95.0}/src/aria_code/_version.py

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

{aria_code-0.93.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.95.0/src/aria_code/apps/cli/exec_events.py

@@ -0,0 +1,83 @@
+"""JSON events for `aria-code -p … --format jsonl`, one per line, as the turn runs.
+
+`-p --json` printed one document at the end, so a CI job saw nothing until the
+turn was over and could not tell which tool ran, how long it took or where
+it failed. With jsonl each step is a line on stdout as it happens:
+
+    {"type": "turn.started", "prompt": "...", "model": "...", "ts": ...}
+    {"type": "tool.started", "tool": "run_command", "params": {...}, "ts": ...}
+    {"type": "tool.completed", "tool": "run_command", "success": true, "elapsed_s": 1.2,
+     "error": "", "ts": ...}
+    {"type": "turn.completed", "success": true, "response": "...", "tools_used": [...], ...}
+
+Tool parameters are shortened and secrets masked: a written file's contents
+or a command's token have no place in a CI log.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, TextIO
+
+from aria_code.apps.cli.runtime_consumer import MEASURED_ELAPSED_KEY, _redact_activity_text
+
+PARAM_CHARS = 300
+
+
+def json_safe(value: Any) -> Any:
+    """``value`` with anything json cannot write turned into text."""
+    return json.loads(json.dumps(value, ensure_ascii=False, default=str))
+
+
+def _param_view(params: dict) -> dict:
+    view = {}
+    for key, value in (params or {}).items():
+        if str(key).startswith("_"):
+            continue                       # execution context the host added
+        if isinstance(value, str):
+            # A file's contents is not a parameter worth a log line; its size is.
+            view[key] = (f"<{len(value)} chars>" if len(value) > 2000
+                         else _redact_activity_text(value, limit=PARAM_CHARS))
+        elif isinstance(value, (int, float, bool)) or value is None:
+            view[key] = value
+        else:
+            view[key] = _redact_activity_text(json.dumps(value, ensure_ascii=False, default=str),
+                                              limit=PARAM_CHARS)
+    return view
+
+
+class ExecEvents:
+    """Writes events to ``out``; does nothing when ``out`` is None."""
+
+    def __init__(self, out: TextIO | None):
+        self.out = out
+
+    def emit(self, event_type: str, **fields: Any) -> None:
+        if self.out is None:
+            return
+        record = {"type": event_type, **json_safe(fields), "ts": round(time.time(), 3)}
+        try:
+            self.out.write(json.dumps(record, ensure_ascii=False) + "\n")
+            self.out.flush()
+        except (OSError, ValueError):
+            self.out = None                # the reader went away; stop writing
+
+    def tool_started(self, tool: str, params: dict) -> None:
+        self.emit("tool.started", tool=tool, params=_param_view(params))
+
+    def tool_completed(self, tool: str, result: dict) -> None:
+        result = result if isinstance(result, dict) else {"success": bool(result)}
+        fields: dict[str, Any] = {"tool": tool, "success": bool(result.get("success", True))}
+        if isinstance(result.get(MEASURED_ELAPSED_KEY), (int, float)):
+            fields["elapsed_s"] = round(float(result[MEASURED_ELAPSED_KEY]), 3)
+        if result.get("error"):
+            fields["error"] = _redact_activity_text(result["error"], limit=PARAM_CHARS)
+        data = result.get("data") if isinstance(result.get("data"), dict) else {}
+        for key in ("exit_code", "path", "process_id", "change_id"):
+            if key in data:
+                fields[key] = data[key]
+        self.emit("tool.completed", **fields)
+
+
+__all__ = ["ExecEvents", "json_safe"]

{aria_code-0.93.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"]