aria-code 4.1.3__py3-none-any.whl

apps/cli/market_universe.py

@@ -0,0 +1,265 @@
+"""Market symbol resolution across A-shares, HK, global tickers, FX and futures.
+
+The resolver is intentionally cache-first. Static aliases cover common global
+assets and critical names; optional akshare loaders populate full A-share/HK
+name tables into a local cache when available.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+import re
+import time
+from typing import Callable, Iterable
+
+
+@dataclass(frozen=True)
+class MarketSymbol:
+    name: str
+    symbol: str
+    market: str
+    source: str = "static"
+
+
+STATIC_MARKET_ALIASES: dict[str, MarketSymbol] = {
+    # A-share fixes and high-frequency names not guaranteed in older static maps
+    "斯迪克": MarketSymbol("斯迪克", "300806", "CN", "static"),
+    # China / HK indices
+    "上证指数": MarketSymbol("上证指数", "000001.SS", "INDEX", "static"),
+    "上证": MarketSymbol("上证指数", "000001.SS", "INDEX", "static"),
+    "深证成指": MarketSymbol("深证成指", "399001.SZ", "INDEX", "static"),
+    "创业板指": MarketSymbol("创业板指", "399006.SZ", "INDEX", "static"),
+    "沪深300": MarketSymbol("沪深300", "000300.SS", "INDEX", "static"),
+    "中证500": MarketSymbol("中证500", "000905.SS", "INDEX", "static"),
+    "恒生指数": MarketSymbol("恒生指数", "^HSI", "INDEX", "static"),
+    "恒指": MarketSymbol("恒生指数", "^HSI", "INDEX", "static"),
+    # US/global indices
+    "标普500": MarketSymbol("标普500", "^GSPC", "INDEX", "static"),
+    "标普": MarketSymbol("标普500", "^GSPC", "INDEX", "static"),
+    "纳斯达克": MarketSymbol("纳斯达克综合", "^IXIC", "INDEX", "static"),
+    "纳指": MarketSymbol("纳斯达克综合", "^IXIC", "INDEX", "static"),
+    "道琼斯": MarketSymbol("道琼斯工业指数", "^DJI", "INDEX", "static"),
+    "道指": MarketSymbol("道琼斯工业指数", "^DJI", "INDEX", "static"),
+    "罗素2000": MarketSymbol("罗素2000", "^RUT", "INDEX", "static"),
+    "恐慌指数": MarketSymbol("VIX", "^VIX", "INDEX", "static"),
+    "vix": MarketSymbol("VIX", "^VIX", "INDEX", "static"),
+    "富时100": MarketSymbol("FTSE 100", "^FTSE", "INDEX", "static"),
+    "德国dax": MarketSymbol("DAX", "^GDAXI", "INDEX", "static"),
+    "dax": MarketSymbol("DAX", "^GDAXI", "INDEX", "static"),
+    "法国cac": MarketSymbol("CAC 40", "^FCHI", "INDEX", "static"),
+    "日经225": MarketSymbol("Nikkei 225", "^N225", "INDEX", "static"),
+    # Europe equities / brands frequently asked by name rather than ticker.
+    "lvmh": MarketSymbol("LVMH Moet Hennessy Louis Vuitton SE", "MC.PA", "EU", "static"),
+    "路易威登": MarketSymbol("LVMH Moet Hennessy Louis Vuitton SE", "MC.PA", "EU", "static"),
+    "路易斯威登": MarketSymbol("LVMH Moet Hennessy Louis Vuitton SE", "MC.PA", "EU", "static"),
+    "louis vuitton": MarketSymbol("LVMH Moet Hennessy Louis Vuitton SE", "MC.PA", "EU", "static"),
+    "爱马仕": MarketSymbol("Hermes International SCA", "RMS.PA", "EU", "static"),
+    "开云集团": MarketSymbol("Kering SA", "KER.PA", "EU", "static"),
+    "古驰": MarketSymbol("Kering SA", "KER.PA", "EU", "static"),
+    # Crypto
+    "比特币": MarketSymbol("比特币", "BTC-USD", "CRYPTO", "static"),
+    "btc": MarketSymbol("Bitcoin", "BTC-USD", "CRYPTO", "static"),
+    "以太坊": MarketSymbol("以太坊", "ETH-USD", "CRYPTO", "static"),
+    "eth": MarketSymbol("Ethereum", "ETH-USD", "CRYPTO", "static"),
+    "狗狗币": MarketSymbol("Dogecoin", "DOGE-USD", "CRYPTO", "static"),
+    "sol": MarketSymbol("Solana", "SOL-USD", "CRYPTO", "static"),
+    "索拉纳": MarketSymbol("Solana", "SOL-USD", "CRYPTO", "static"),
+    # FX
+    "美元人民币": MarketSymbol("USD/CNY", "CNY=X", "FX", "static"),
+    "人民币汇率": MarketSymbol("USD/CNY", "CNY=X", "FX", "static"),
+    "美元兑人民币": MarketSymbol("USD/CNY", "CNY=X", "FX", "static"),
+    "美元指数": MarketSymbol("美元指数", "DX-Y.NYB", "FX", "static"),
+    "欧元美元": MarketSymbol("EUR/USD", "EURUSD=X", "FX", "static"),
+    "欧元兑美元": MarketSymbol("EUR/USD", "EURUSD=X", "FX", "static"),
+    "美元日元": MarketSymbol("USD/JPY", "JPY=X", "FX", "static"),
+    "英镑美元": MarketSymbol("GBP/USD", "GBPUSD=X", "FX", "static"),
+    # Futures / commodities via Yahoo continuous futures
+    "黄金": MarketSymbol("黄金期货", "GC=F", "FUTURES", "static"),
+    "白银": MarketSymbol("白银期货", "SI=F", "FUTURES", "static"),
+    "原油": MarketSymbol("WTI原油期货", "CL=F", "FUTURES", "static"),
+    "wti": MarketSymbol("WTI原油期货", "CL=F", "FUTURES", "static"),
+    "布伦特": MarketSymbol("布伦特原油期货", "BZ=F", "FUTURES", "static"),
+    "铜": MarketSymbol("铜期货", "HG=F", "FUTURES", "static"),
+    "天然气": MarketSymbol("天然气期货", "NG=F", "FUTURES", "static"),
+    "玉米": MarketSymbol("玉米期货", "ZC=F", "FUTURES", "static"),
+    "大豆": MarketSymbol("大豆期货", "ZS=F", "FUTURES", "static"),
+}
+
+
+def _cache_path() -> Path:
+    root = Path(os.getenv("ARIA_CACHE_DIR") or (Path.home() / ".aria" / "cache"))
+    return root / "market_universe.json"
+
+
+def _load_cache(path: Path | None = None, *, max_age_seconds: int = 7 * 86400) -> list[MarketSymbol]:
+    path = path or _cache_path()
+    try:
+        if not path.exists() or time.time() - path.stat().st_mtime > max_age_seconds:
+            return []
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        return [
+            MarketSymbol(
+                name=str(item.get("name") or ""),
+                symbol=str(item.get("symbol") or ""),
+                market=str(item.get("market") or ""),
+                source=str(item.get("source") or "cache"),
+            )
+            for item in payload.get("symbols", [])
+            if item.get("name") and item.get("symbol")
+        ]
+    except Exception:
+        return []
+
+
+def _write_cache(symbols: Iterable[MarketSymbol], path: Path | None = None) -> None:
+    path = path or _cache_path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            "updated_at": int(time.time()),
+            "symbols": [s.__dict__ for s in symbols if s.name and s.symbol],
+        }
+        path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def _iter_static_symbols() -> list[MarketSymbol]:
+    seen: set[tuple[str, str]] = set()
+    out: list[MarketSymbol] = []
+    for item in STATIC_MARKET_ALIASES.values():
+        key = (item.name, item.symbol)
+        if key not in seen:
+            out.append(item)
+            seen.add(key)
+    return out
+
+
+def _symbols_from_frame(frame, *, name_cols: tuple[str, ...], code_cols: tuple[str, ...], market: str, source: str) -> list[MarketSymbol]:
+    out: list[MarketSymbol] = []
+    try:
+        columns = {str(c).lower(): c for c in frame.columns}
+        name_col = next((columns[c.lower()] for c in name_cols if c.lower() in columns), None)
+        code_col = next((columns[c.lower()] for c in code_cols if c.lower() in columns), None)
+        if name_col is None or code_col is None:
+            return []
+        for _, row in frame.iterrows():
+            name = str(row.get(name_col, "")).strip()
+            code = str(row.get(code_col, "")).strip().upper()
+            if not name or not code or code.lower() == "nan":
+                continue
+            if market == "HK":
+                digits = re.sub(r"\D", "", code)
+                if digits:
+                    code = f"{digits.zfill(4)}.HK"
+            out.append(MarketSymbol(name, code, market, source))
+    except Exception:
+        return []
+    return out
+
+
+def fetch_market_universe() -> list[MarketSymbol]:
+    """Fetch A-share and HK symbol tables when akshare is available."""
+    symbols = _iter_static_symbols()
+    try:
+        import akshare as ak
+        try:
+            a_df = ak.stock_info_a_code_name()
+            symbols.extend(_symbols_from_frame(
+                a_df,
+                name_cols=("name", "证券简称", "股票简称", "名称"),
+                code_cols=("code", "证券代码", "股票代码", "代码"),
+                market="CN",
+                source="akshare:a_code_name",
+            ))
+        except Exception:
+            pass
+        try:
+            hk_df = ak.stock_hk_spot_em()
+            symbols.extend(_symbols_from_frame(
+                hk_df,
+                name_cols=("名称", "股票简称", "name"),
+                code_cols=("代码", "code", "股票代码"),
+                market="HK",
+                source="akshare:hk_spot",
+            ))
+        except Exception:
+            pass
+    except Exception:
+        pass
+
+    dedup: dict[tuple[str, str], MarketSymbol] = {}
+    for item in symbols:
+        dedup[(item.name.lower(), item.symbol.upper())] = item
+    return list(dedup.values())
+
+
+def ensure_market_universe(*, force: bool = False) -> list[MarketSymbol]:
+    cached = [] if force else _load_cache()
+    if cached:
+        return _iter_static_symbols() + cached
+    fetched = fetch_market_universe()
+    _write_cache(fetched)
+    return fetched
+
+
+def resolve_market_mentions(
+    text: str,
+    *,
+    limit: int = 6,
+    load_universe: Callable[[], list[MarketSymbol]] | None = None,
+) -> list[tuple[int, MarketSymbol]]:
+    """Resolve named market assets mentioned in text, preserving positions."""
+    if not text:
+        return []
+    low = text.lower()
+    hits: list[tuple[int, MarketSymbol]] = []
+    for alias, item in sorted(STATIC_MARKET_ALIASES.items(), key=lambda kv: -len(kv[0])):
+        idx = low.find(alias.lower())
+        if idx >= 0:
+            hits.append((idx, item))
+
+    def scan(items: Iterable[MarketSymbol]) -> None:
+        for item in sorted(items, key=lambda s: -len(s.name)):
+            if not item.name:
+                continue
+            idx = low.find(item.name.lower())
+            if idx >= 0:
+                hits.append((idx, item))
+
+    if load_universe is not None:
+        scan(load_universe())
+    else:
+        scan(_load_cache())
+        market_words = "走势|预测|股价|股票|行情|趋势|技术面|基本面|涨跌|价格|市值|k线|图表|财报"
+        if not hits and re.search(r"[\u4e00-\u9fff]", text) and re.search(market_words, text, re.I):
+            scan(ensure_market_universe(force=True))
+
+    ordered: list[tuple[int, MarketSymbol]] = []
+    seen_symbols: set[str] = set()
+    for idx, item in sorted(hits, key=lambda pair: (pair[0], -len(pair[1].name))):
+        sym = item.symbol.upper()
+        if sym in seen_symbols:
+            continue
+        ordered.append((idx, item))
+        seen_symbols.add(sym)
+        if len(ordered) >= limit:
+            break
+    return ordered
+
+
+def resolve_market_symbol(text: str) -> str:
+    hits = resolve_market_mentions(text, limit=1)
+    return hits[0][1].symbol if hits else ""
+
+
+def looks_like_unresolved_market_name(text: str) -> bool:
+    """Heuristic guard: a Chinese name before market words should not inherit history."""
+    if resolve_market_symbol(text):
+        return False
+    if not re.search(r"[\u4e00-\u9fff]{2,12}", text or ""):
+        return False
+    market_words = "走势|预测|股价|股票|行情|趋势|技术面|基本面|涨跌|价格|市值"
+    return bool(re.search(rf"[\u4e00-\u9fffA-Za-z0-9]{{2,16}}(?:的)?(?:{market_words})", text or ""))

apps/cli/message_processing.py

@@ -0,0 +1,257 @@
+"""Message processing utilities extracted from aria_cli.py.
+
+Functions here handle: parsing tool calls from text, stripping tool tags
+from display output, and compacting conversation history.
+
+Dependencies on aria_cli globals (LOCAL_TOOLS, get_model_cfg) are resolved
+via lazy runtime imports to avoid circular import at load time.
+"""
+from __future__ import annotations
+
+import json
+import re
+from typing import Optional
+
+
+def _local_tools() -> dict:
+    import aria_cli
+    return aria_cli.LOCAL_TOOLS
+
+
+def _fix_json(raw: str) -> str:
+    import aria_cli
+    return aria_cli._fix_json_string(raw)
+
+
+def _get_model_cfg(key: str) -> dict:
+    import aria_cli
+    return aria_cli.get_model_cfg(key)
+
+
+# ── Tool call parsing ─────────────────────────────────────────────────────────
+
+def parse_text_tool_calls(text: str) -> list:
+    """Parse tool calls from AI response text.
+
+    Supports formats:
+    1. <tool_call>{"name": "...", "arguments": {...}}</tool_call>
+    2. ```json\\n{"name": "...", "arguments": {...}}\\n```
+    3. Bare JSON: {"name": "...", "arguments": {...}}
+    """
+    local_tools = _local_tools()
+    calls: list = []
+
+    def _try_parse(raw: str) -> Optional[dict]:
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            pass
+        try:
+            return json.loads(_fix_json(raw))
+        except json.JSONDecodeError:
+            pass
+        return None
+
+    # Format 1: <tool_call>...</tool_call> tags
+    tag_pattern = re.compile(r'<tool_call>\s*([\s\S]*?)\s*</tool_call>', re.DOTALL)
+    for m in tag_pattern.finditer(text):
+        obj = _try_parse(m.group(1))
+        if obj:
+            name = obj.get("name", "")
+            args = obj.get("arguments", {})
+            if name and name in local_tools:
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args)
+                    except json.JSONDecodeError:
+                        args = json.loads(_fix_json(args))
+                calls.append({"tool": name, "params": args})
+
+    if calls:
+        return calls
+
+    # Format 2: code-fenced JSON
+    fence_pattern = re.compile(r'```(?:json)?\s*\n([\s\S]*?)\n\s*```', re.DOTALL)
+    for m in fence_pattern.finditer(text):
+        obj = _try_parse(m.group(1))
+        if obj:
+            name = obj.get("name", "")
+            args = obj.get("arguments", {})
+            if name and name in local_tools:
+                if isinstance(args, str):
+                    args = _try_parse(args) or {}
+                calls.append({"tool": name, "params": args})
+
+    if calls:
+        return calls
+
+    # Format 3: bare JSON with balanced brace scan
+    brace_depth = 0
+    json_start = -1
+    for i, ch in enumerate(text):
+        if ch == '{':
+            if brace_depth == 0:
+                json_start = i
+            brace_depth += 1
+        elif ch == '}':
+            brace_depth -= 1
+            if brace_depth == 0 and json_start >= 0:
+                candidate = text[json_start:i + 1]
+                obj = _try_parse(candidate)
+                if obj:
+                    name = obj.get("name", "")
+                    args = obj.get("arguments", {})
+                    if name and name in local_tools:
+                        if isinstance(args, str):
+                            args = _try_parse(args) or {}
+                        calls.append({"tool": name, "params": args})
+                json_start = -1
+
+    return calls
+
+
+def strip_tool_call_tags(text: str) -> str:
+    """Remove tool calls from display text (tags, fences, bare JSON, headers)."""
+    local_tools = _local_tools()
+
+    text = re.sub(r'<tool_call>[\s\S]*?</tool_call>', '', text, flags=re.DOTALL)
+
+    def _remove_fence(m: re.Match) -> str:
+        try:
+            obj = json.loads(m.group(1))
+            if obj.get("name") in local_tools and "arguments" in obj:
+                return ''
+        except (json.JSONDecodeError, TypeError):
+            pass
+        return m.group(0)
+
+    text = re.sub(r'```(?:json)?\s*\n([\s\S]*?)\n\s*```', _remove_fence, text, flags=re.DOTALL)
+
+    def _remove_bare(m: re.Match) -> str:
+        try:
+            obj = json.loads(m.group(0))
+            if obj.get("name") in local_tools and "arguments" in obj:
+                return ''
+        except (json.JSONDecodeError, TypeError):
+            pass
+        return m.group(0)
+
+    text = re.sub(
+        r'\{[^{}]*"name"\s*:\s*"[^"]*"[^{}]*"arguments"\s*:\s*\{[\s\S]*?\}\s*\}',
+        _remove_bare, text,
+    )
+    text = re.sub(r'###\s+Step\s+\d+.*\n?', '', text)
+    text = re.sub(r'###\s+.*工具调用.*\n?', '', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    return text.strip()
+
+
+# ── History compaction ────────────────────────────────────────────────────────
+
+def estimate_message_tokens(messages: list, extra_content: str = "") -> int:
+    """Return a rough token estimate matching the terminal context meter."""
+    from packages.aria_services.context import ContextService
+
+    return ContextService.estimate_message_tokens(messages, extra_content=extra_content)
+
+
+def context_compaction_decision(
+    messages: list,
+    *,
+    model_key: str = "qwen7b",
+    extra_content: str = "",
+    threshold: float = 0.78,
+    min_messages: int = 8,
+) -> dict:
+    """Decide whether a conversation should be compacted before the next turn."""
+    try:
+        threshold = float(threshold)
+    except Exception:
+        threshold = 0.78
+    max_ctx = int(_get_model_cfg(model_key).get("num_ctx", 16384) or 16384)
+    from packages.aria_services.context import build_context_service
+
+    service = build_context_service(
+        max_tokens=max_ctx,
+        threshold=threshold,
+        min_messages=min_messages,
+    )
+    return service.compaction_decision(messages, extra_content=extra_content).to_dict()
+
+
+def compact_messages(
+    messages: list,
+    max_chars: int = 0,
+    model_key: str = "qwen7b",
+) -> list:
+    """Smart synchronous compaction for the agentic tool loop.
+
+    Strategy (in order of priority):
+    1. Always keep: system prompt + last 8 messages (recent context).
+    2. For middle tool results: extract status line + error details (if any),
+       drop verbose success payloads.
+    3. For middle assistant turns: keep first paragraph + last sentence.
+    4. Error markers are never discarded.
+    """
+    ctx = int(_get_model_cfg(model_key).get("num_ctx", 16384) or 16384)
+    from packages.aria_services.context import build_context_service
+
+    service = build_context_service(max_tokens=ctx)
+    return service.compact_messages(messages, max_chars=max_chars)
+
+
+# ── Broker context injection ──────────────────────────────────────────────────
+
+def build_broker_context_block() -> str:
+    """Return a compact broker context block for injection into the system prompt.
+
+    Returns "" if no broker is connected or data fetch fails.
+    """
+    import aria_cli as _ac
+    if not getattr(_ac, "_HAS_BROKERS", False):
+        return ""
+    try:
+        reg = _ac._get_broker_registry()
+        if not reg:
+            return ""
+        broker = reg.active()
+        if not broker or not broker.is_connected:
+            return ""
+
+        parts = [f"## 券商账户实时快照 [{broker.label}]"]
+
+        try:
+            acct = broker.account_info()
+            parts.append(
+                f"- 账户: {acct.masked_account}  货币: {acct.currency}\n"
+                f"- 总资产: {acct.total_assets:,.2f}  可用现金: {acct.cash:,.2f}"
+                f"  持仓市值: {acct.market_value:,.2f}"
+            )
+            if acct.pnl_today:
+                parts.append(f"- 当日盈亏: {acct.pnl_today:+,.2f}")
+        except Exception:
+            pass
+
+        try:
+            positions = broker.positions()
+            if positions:
+                positions_sorted = sorted(positions, key=lambda p: -abs(p.market_value))[:10]
+                parts.append("\n持仓明细（市值降序，最多10条）：")
+                for p in positions_sorted:
+                    pnl_str = f"  盈亏 {p.pnl:+,.2f} ({p.pnl_pct:+.2f}%)" if p.pnl else ""
+                    parts.append(
+                        f"  {p.symbol} {p.name[:8] if p.name else ''}  "
+                        f"持仓 {p.quantity:.0f}  成本 {p.cost_price:.3f}  "
+                        f"现价 {p.current_price:.3f}  市值 {p.market_value:,.2f}{pnl_str}"
+                    )
+        except Exception:
+            pass
+
+        if len(parts) <= 1:
+            return ""
+
+        parts.append("\n(以上为实时账户数据，无需再调用 broker_query 获取基本账户/持仓信息，可直接引用。)")
+        return "\n".join(parts)
+
+    except Exception:
+        return ""

apps/cli/plan_mode.py

@@ -0,0 +1,139 @@
+"""Interactive plan mode — intercept tool calls for step-by-step approval.
+
+When plan mode is active, the agent loop asks the user to approve each tool
+call before execution. A plan-mode header shows which step is being proposed.
+
+Usage (from aria_cli.py):
+    from apps.cli.plan_mode import PlanModeState
+
+    _PLAN = PlanModeState()          # module-level singleton
+
+    # Enter plan mode:
+    _PLAN.enter()
+
+    # In _confirm_tool_execution_decision:
+    if _PLAN.active and tool_name not in _CONFIRM_TOOLS:
+        return _PLAN.confirm_step(tool_name, params, console, HAS_RICH)
+
+    # Exit:
+    _PLAN.exit()
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class PlanStep:
+    index: int
+    tool: str
+    params: dict
+    approved: Optional[bool] = None
+    skipped: bool = False
+
+
+@dataclass
+class PlanModeState:
+    active: bool = False
+    _steps: List[PlanStep] = field(default_factory=list)
+    _index: int = 0
+
+    # ── Lifecycle ─────────────────────────────────────────────────────────────
+
+    def enter(self) -> None:
+        self.active = True
+        self._steps = []
+        self._index = 0
+
+    def exit(self) -> None:
+        self.active = False
+        self._steps = []
+        self._index = 0
+
+    # ── Step tracking ─────────────────────────────────────────────────────────
+
+    def _next_index(self) -> int:
+        self._index += 1
+        return self._index
+
+    def record_step(self, tool: str, params: dict, *, approved: bool) -> PlanStep:
+        step = PlanStep(index=self._next_index(), tool=tool, params=params, approved=approved)
+        self._steps.append(step)
+        return step
+
+    def summary(self) -> dict:
+        total = len(self._steps)
+        approved = sum(1 for s in self._steps if s.approved is True)
+        rejected = sum(1 for s in self._steps if s.approved is False)
+        return {"total": total, "approved": approved, "rejected": rejected}
+
+    # ── Confirmation UI ───────────────────────────────────────────────────────
+
+    def confirm_step(
+        self,
+        tool_name: str,
+        params: dict,
+        *,
+        console,
+        has_rich: bool,
+        arrow_select_fn,
+    ):
+        """Show plan-mode confirmation prompt. Returns ApprovalDecision."""
+        from runtime.approval import ApprovalDecision
+
+        step_num = self._index + 1  # preview next number
+
+        if has_rich and console:
+            _param_preview = _format_params(params)
+            console.print(
+                f"\n  [bold cyan]◆ Plan Mode[/bold cyan]  "
+                f"[dim]Step {step_num} — tool:[/dim] [bold]{tool_name}[/bold]"
+            )
+            if _param_preview:
+                console.print(f"  [dim]{_param_preview}[/dim]")
+        else:
+            print(f"\n  [Plan Mode] Step {step_num}: {tool_name}")
+
+        options = [
+            ("Execute this step",        "执行此工具调用"),
+            ("Skip this step",           "跳过，继续下一步"),
+            ("Execute all remaining",    "从此步开始自动执行所有后续工具"),
+            ("Abort plan",               "取消整个任务"),
+        ]
+
+        choice = arrow_select_fn(options, selected=0, title="")
+
+        if choice == 0:
+            self.record_step(tool_name, params, approved=True)
+            return ApprovalDecision.allow()
+        elif choice == 1:
+            self.record_step(tool_name, params, approved=False)
+            return ApprovalDecision.deny("skipped in plan mode")
+        elif choice == 2:
+            self.record_step(tool_name, params, approved=True)
+            self.exit()  # turn off plan mode so remaining tools auto-execute
+            return ApprovalDecision.allow(auto_approve_session=True)
+        else:
+            self.record_step(tool_name, params, approved=False)
+            self.exit()
+            return ApprovalDecision.deny("plan aborted by user")
+
+
+def _format_params(params: dict) -> str:
+    """Return a short one-line preview of tool params."""
+    parts = []
+    for key in ("path", "command", "url", "query", "symbol", "action"):
+        if key in params:
+            val = str(params[key])
+            if len(val) > 80:
+                val = val[:77] + "…"
+            parts.append(f"{key}={val!r}")
+    if not parts and params:
+        first_key = next(iter(params))
+        val = str(params[first_key])
+        if len(val) > 80:
+            val = val[:77] + "…"
+        parts.append(f"{first_key}={val!r}")
+    return "  ".join(parts)

apps/cli/plotly_html.py

@@ -0,0 +1,15 @@
+"""Helpers for generating offline-safe Plotly HTML fragments."""
+from __future__ import annotations
+
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def plotly_script_tag() -> str:
+    """Return an inline Plotly <script> tag when the package is available."""
+    try:
+        from plotly.offline import get_plotlyjs
+
+        return f"<script>{get_plotlyjs()}</script>"
+    except Exception:
+        return '<script src="https://cdn.plot.ly/plotly-2.35.2.min.js"></script>'