aria-code 0.52.0__py3-none-any.whl

aria_code/apps/cli/handlers/realty_handlers.py

@@ -0,0 +1,114 @@
+"""Deterministic real-estate query handler extracted from aria_cli.py."""
+from __future__ import annotations
+
+from typing import Callable
+
+
+def handle_realty_query(
+    message: str,
+    *,
+    is_realty_query: Callable[[str], bool],
+    cn_cities: tuple | list,
+    intl_cities: tuple | list,
+) -> dict:
+    """Deterministic handler for natural-language real-estate / housing questions.
+
+    Detects city names + real-estate keywords and calls the realty data tools
+    directly, returning a formatted response without needing the LLM to parse it.
+    """
+    if not is_realty_query(message):
+        return {"success": False, "error": "not_realty_query"}
+
+    try:
+        from realty_data_tools import get_house_price_index, get_re_investment
+    except ImportError:
+        return {"success": False, "error": "realty_data_tools_not_available"}
+
+    cities_found: list[str] = []
+    for city in cn_cities:
+        if city in message:
+            cities_found.append(city)
+        if len(cities_found) >= 2:
+            break
+
+    _low_msg = message.lower()
+    _intl_found = [c for c in intl_cities if c in _low_msg]
+
+    if _intl_found and not cities_found:
+        _intl_name = _intl_found[0]
+        return {
+            "success": True,
+            "response": (
+                f"## 🌍 {_intl_name.title()} 房地产市场\n\n"
+                f"国际城市房价数据目前依赖 LLM 知识库分析（无实时数据接入）。\n\n"
+                f"**当前支持实时数据的城市：** 中国大陆 70 个主要城市（北上广深等）\n\n"
+                f"如需国际市场数据，建议查阅：\n"
+                f"- 美国：`/realty us` — 联邦住房数据（Case-Shiller 指数、新屋开工）\n"
+                f"- 其他国际城市：可直接提问，Aria 将基于训练知识回答（数据截止至知识库更新时间）\n\n"
+                f"---\n\n"
+                f"请问您具体想了解 **{_intl_name.title()}** 哪方面的房地产信息？"
+            ),
+            "tools_used": ["realty_query"],
+        }
+
+    city1 = cities_found[0] if cities_found else "全国"
+    city2 = cities_found[1] if len(cities_found) > 1 else ("上海" if city1 != "上海" else "北京")
+
+    lines: list[str] = []
+    lines.append(f"## 🏠 {city1} 房地产市场")
+    if len(cities_found) > 1:
+        lines[-1] += f" vs {city2}"
+    lines.append("")
+
+    try:
+        r = get_house_price_index(city1, city2)
+        if r.get("success"):
+            for lbl, cd in (
+                (city1, r.get("latest_city1", {})),
+                (city2, r.get("latest_city2", {})),
+            ):
+                if not cd:
+                    continue
+                lines.append(f"### {lbl}")
+                if cd.get("new_yoy") is not None:
+                    lines.append(f"- **新房同比**：{float(cd['new_yoy']):+.2f}%")
+                if cd.get("new_mom") is not None:
+                    lines.append(f"- **新房环比**：{float(cd['new_mom']):+.2f}%")
+                if cd.get("second_yoy") is not None:
+                    lines.append(f"- **二手房同比**：{float(cd['second_yoy']):+.2f}%")
+                if cd.get("second_mom") is not None:
+                    lines.append(f"- **二手房环比**：{float(cd['second_mom']):+.2f}%")
+                if cd.get("date"):
+                    lines.append(f"- **数据期**：{cd['date']}")
+                lines.append("")
+        else:
+            lines.append(f"房价指数数据暂时不可用（{r.get('error', '数据源未响应')}）")
+            lines.append("")
+    except Exception as _e:
+        lines.append(f"获取房价数据失败: {_e}")
+        lines.append("")
+
+    try:
+        ri = get_re_investment()
+        if ri.get("success") and ri.get("latest"):
+            lt = ri["latest"]
+            lines.append("### 全国房地产开发投资")
+            lines.append(f"- **最新值**：{lt.get('最新值', 'N/A')}")
+            lines.append(f"- **日期**：{lt.get('日期', 'N/A')}")
+            lines.append(f"- **涨跌幅**：{lt.get('涨跌幅', 'N/A')}")
+            lines.append(f"- **近1年涨跌幅**：{lt.get('近1年涨跌幅', 'N/A')}")
+            lines.append("")
+    except Exception:
+        pass
+
+    lines.append("**更多操作**")
+    lines.append(f"- `/realty market {city1}` — 完整城市房价走势图")
+    lines.append(f"- `/realty compare {city1} {city2}` — 城市横向对比")
+    lines.append("- `/realty rent` — 租金收益率计算")
+    lines.append("- `/realty reit` — REIT 市场数据")
+
+    return {
+        "success": True,
+        "response": "\n".join(lines),
+        "tools_used": ["realty_query"],
+    }

aria_code/apps/cli/handlers/sports_handlers.py

@@ -0,0 +1,22 @@
+"""Sports context prefetch for the chat path.
+
+The market equivalent already lives in handlers/market_handlers.py; this one
+was still inline in aria_cli and borrowed from its globals by stream_ollama,
+so the fallback path (SDK, daemon) raised NameError on any sports query.
+
+Kept deliberately quiet: a prefetch is an optimisation, and a missing or
+failing football client must degrade to "no extra context" rather than break
+the turn.
+"""
+
+from __future__ import annotations
+
+
+def try_prefetch_sports_data(message: str) -> str:
+    """Live sports context for a query, or "" when unavailable."""
+    try:
+        from football_data_client import get_sports_context_for_query
+
+        return get_sports_context_for_query(message) or ""
+    except Exception:
+        return ""

aria_code/apps/cli/handlers/strategy_advice.py

@@ -0,0 +1,82 @@
+"""Deterministic strategy-advice responses.
+
+This keeps advisory questions from being treated as code-generation tasks.
+When the user asks "how should I write a strategy" or "from which angles",
+the CLI should answer with a framework and explicit next commands, not create
+files or run backtests without a generation/execution intent.
+"""
+
+from __future__ import annotations
+
+
+_STRATEGY_TERMS = (
+    "量化策略", "交易策略", "美股策略", "回测策略", "策略框架",
+    "quant strategy", "trading strategy", "backtest strategy",
+)
+
+_ADVICE_TERMS = (
+    "几个角度", "哪些角度", "从几个方面", "怎么写", "如何写",
+    "思路", "框架", "结构", "要考虑", "你觉得", "建议",
+    "how", "what should", "framework", "approach", "angles",
+)
+
+_EXECUTION_TERMS = (
+    "开始写", "帮我写", "生成", "实现", "创建", "保存", "运行",
+    "回测一下", "直接做", "落地", "完善代码",
+    "write", "generate", "implement", "create", "save", "run",
+)
+
+
+def is_strategy_advice_request(message: str) -> bool:
+    text = (message or "").strip()
+    if not text or text.startswith("/"):
+        return False
+    low = text.lower()
+    has_strategy = any(term in text or term in low for term in _STRATEGY_TERMS)
+    has_advice = any(term in text or term in low for term in _ADVICE_TERMS)
+    has_execution = any(term in text or term in low for term in _EXECUTION_TERMS)
+    return bool(has_strategy and has_advice and not has_execution)
+
+
+def handle_strategy_advice(message: str) -> dict:
+    if not is_strategy_advice_request(message):
+        return {"success": False, "error": "not_strategy_advice"}
+
+    response = """## 美股量化策略写作框架
+
+建议从 8 个层级写，先定义假设，再验证和风控，最后才进入交易执行。
+当前是咨询型问题，不需要先写文件，也不会自动运行回测。
+
+| 层级 | 要解决的问题 | 产物 |
+|---|---|---|
+| 1. 市场假设 | 为什么这个信号可能赚钱 | 策略假设、适用市场、失效条件 |
+| 2. 标的池 | 交易哪些股票/ETF，如何剔除不可交易标的 | universe 规则、流动性/价格过滤 |
+| 3. 数据层 | OHLCV、财报、因子、宏观、新闻是否可得且可信 | 数据源、清洗、复权、缺失处理 |
+| 4. 信号层 | 入场/出场依据是什么 | 因子、阈值、信号延迟、防未来函数 |
+| 5. 组合层 | 单票仓位、行业暴露、相关性怎么控制 | 权重、再平衡、最大持仓、现金规则 |
+| 6. 交易成本 | 手续费、滑点、冲击成本是否吞噬收益 | 成本模型、成交假设 |
+| 7. 回测评估 | 策略是否稳健，而不是只在样本内好看 | CAGR、Sharpe、最大回撤、胜率、换手、分阶段表现 |
+| 8. 风控部署 | 实盘如何限制损失并监控失效 | 止损、熔断、告警、paper/live 分层 |
+
+**推荐落地顺序**
+
+1. 先写一页策略说明：假设、标的池、调仓频率、风险边界。
+2. 再写最小回测脚本：只包含数据、信号、仓位、绩效。
+3. 加 walk-forward、不同市场阶段、参数敏感性测试。
+4. 通过后接 paper trading，不直接上实盘。
+5. 实盘前加入订单预览、资金上限、熔断、审计日志。
+
+**下一步命令**
+
+- `/scaffold my_us_strategy --template strategy`：生成策略项目骨架。
+- `/backtest momentum SPY --period 1y`：先跑一个内置动量回测。
+- `/auto-strategy momentum SPY --target sharpe=1.2`：进入自动优化流程。
+
+*这只是策略设计框架，不构成投资建议。需要我生成代码时，请明确说“生成/实现/写文件”。*"""
+
+    return {
+        "success": True,
+        "response": response,
+        "tools_used": ["strategy_advice"],
+        "analysis_complete": True,
+    }

aria_code/apps/cli/helpers.py

@@ -0,0 +1,302 @@
+"""Stateless helpers lifted out of aria_cli.py.
+
+These twelve functions never touched aria_cli's module state — no console, no
+HAS_RICH, no tool registry — yet twelve command mixins reached back into a
+7000-line module to call them, because that is simply where they happened to
+be defined. Nothing about them needs to live there.
+
+aria_cli re-exports them under their original names, so its own callers and the
+globals-rebind for the modules that still rely on it are unaffected.
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+from typing import Optional
+
+__all__ = [
+    "detect_ollama_models",
+    "detect_ollama_models_rich",
+    "_load_project_context",
+    "_display_value",
+    "_chart_display_label",
+    "_chart_period_from_ta_days",
+    "_copy_text_to_clipboard",
+    "_reveal_path_in_finder",
+    "_open_path_or_url",
+    "_extract_code_block",
+    "_clean_tool_error_message",
+    "_fuzzy_match",
+    "_is_ashare_symbol",
+    "format_sparkline",
+]
+
+
+def _load_project_context() -> str:
+    """Load ARIA.md / CLAUDE.md by walking up from cwd (Claude Code style).
+
+    Search order per directory: ARIA.md → .aria.md → CLAUDE.md
+    Walks up at most 5 levels, stops at home dir.
+    Multiple files are concatenated (child file takes precedence at top).
+    Total cap: 12KB.
+    """
+    _MAX_BYTES = 12288
+    _MAX_LEVELS = 5
+    _NAMES = ("ARIA.md", ".aria.md", "CLAUDE.md")
+
+    home = pathlib.Path.home()
+    cwd  = pathlib.Path.cwd().resolve()
+
+    found: list[tuple[pathlib.Path, str]] = []  # (file_path, content)
+    current = cwd
+    for _ in range(_MAX_LEVELS):
+        for name in _NAMES:
+            p = current / name
+            if p.is_file():
+                try:
+                    content = p.read_text(encoding="utf-8")
+                    found.append((p, content))
+                except Exception:
+                    pass
+                break  # only one file per directory level
+        if current == home or current.parent == current:
+            break
+        current = current.parent
+
+    # Global user file — lowest priority background layer, project files override it.
+    # Lives at ~/.arthera/ARIA.md; user can edit with /memory edit global
+    _global_aria = home / ".arthera" / "ARIA.md"
+    if _global_aria.is_file() and not any(f == _global_aria for f, _ in found):
+        try:
+            _gc = _global_aria.read_text(encoding="utf-8")
+            if _gc.strip():
+                found.insert(0, (_global_aria, _gc))   # prepend = lowest priority
+        except Exception:
+            pass
+
+    if not found:
+        return ""
+
+    # Child directories first (most specific context wins), then parents
+    blocks: list[str] = []
+    total = 0
+    for fpath, content in found:
+        rel = fpath.relative_to(home) if fpath.is_relative_to(home) else fpath
+        snippet = content[:(_MAX_BYTES - total)]
+        blocks.append(f"### {rel}\n{snippet}")
+        total += len(snippet)
+        if total >= _MAX_BYTES:
+            break
+
+    return "\n\n## Project Context\n" + "\n\n".join(blocks)
+
+
+def _display_value(value, digits: int = 2, suffix: str = "") -> str:
+    try:
+        if value in (None, "", "N/A", "-", "nan"):
+            return "—"
+        if isinstance(value, (int, float)):
+            return f"{float(value):,.{digits}f}{suffix}"
+        return str(value)
+    except Exception:
+        return "—"
+
+
+def _chart_display_label(raw: str, resolved: str, result: dict | None = None) -> str:
+    result = result or {}
+    name = str(result.get("name") or result.get("display_name") or "").strip()
+    resolved = str(resolved or "").strip().upper()
+    raw_label = str(raw or "").strip().upper()
+    if name and name.upper() != resolved:
+        return f"{name} ({resolved})"
+    if raw_label and raw_label != resolved and not raw_label.startswith(resolved):
+        return f"{raw_label} ({resolved})"
+    return resolved or raw_label or "chart"
+
+
+def _chart_period_from_ta_days(days: int) -> str:
+    try:
+        d = int(days)
+    except Exception:
+        return "1y"
+    if d <= 45:
+        return "1mo"
+    if d <= 110:
+        return "3mo"
+    if d <= 220:
+        return "6mo"
+    if d <= 430:
+        return "1y"
+    if d <= 800:
+        return "2y"
+    return "3y"
+
+
+def _copy_text_to_clipboard(text: str) -> tuple[bool, str]:
+    try:
+        import subprocess as _sp
+        _sp.run(["pbcopy"], input=text.encode("utf-8"), check=True, timeout=3)
+        return True, ""
+    except Exception as exc:
+        return False, str(exc)
+
+
+def _reveal_path_in_finder(path: str) -> tuple[bool, str]:
+    try:
+        import subprocess as _sp
+        _sp.Popen(["open", "-R", path])
+        return True, ""
+    except Exception as exc:
+        return False, str(exc)
+
+
+def _open_path_or_url(target: str) -> tuple[bool, str]:
+    try:
+        import subprocess as _sp
+        _sp.Popen(["open", target])
+        return True, ""
+    except Exception as exc:
+        return False, str(exc)
+
+
+def _extract_code_block(text: str) -> Optional[str]:
+    """Extract the first code block from markdown-formatted text."""
+    import re
+    # Match ```python ... ``` or ``` ... ```
+    pattern = r'```(?:python|py)?\s*\n(.*?)```'
+    match = re.search(pattern, text, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+    # Fallback: try to find any code block
+    pattern2 = r'```\w*\s*\n(.*?)```'
+    match2 = re.search(pattern2, text, re.DOTALL)
+    if match2:
+        return match2.group(1).strip()
+    return None
+
+
+def _clean_tool_error_message(error: object) -> str:
+    from ui.render.output import clean_tool_error_message as _ctm
+    return _ctm(error)
+
+
+def _fuzzy_match(query: str, candidates: list, max_results: int = 3) -> list:
+    """Find closest matches using simple edit distance."""
+    def _edit_dist(a, b):
+        if len(a) > len(b):
+            a, b = b, a
+        dists = range(len(a) + 1)
+        for j, cb in enumerate(b):
+            new_dists = [j + 1]
+            for i, ca in enumerate(a):
+                cost = 0 if ca == cb else 1
+                new_dists.append(min(new_dists[-1] + 1, dists[i + 1] + 1, dists[i] + cost))
+            dists = new_dists
+        return dists[-1]
+
+    scored = [(c, _edit_dist(query.lower(), c.lower())) for c in candidates]
+    scored.sort(key=lambda x: x[1])
+    # Only suggest if edit distance is reasonable (< half the length)
+    threshold = max(3, len(query) // 2)
+    return [c for c, d in scored[:max_results] if d <= threshold]
+
+
+def _is_ashare_symbol(symbol: str) -> bool:
+    """Quick check whether a symbol looks like a Chinese A-share code."""
+    s = symbol.strip().lower()
+    return (
+        s.startswith("sh") or s.startswith("sz")
+        or (len(s) == 6 and s.isdigit())
+        or s.endswith(".ss") or s.endswith(".sz")
+    )
+
+
+def format_sparkline(prices: list, width: int = 30) -> str:
+    """Generate Unicode sparkline from price data."""
+    if not prices or len(prices) < 2:
+        return ""
+    blocks = "▁▂▃▄▅▆▇█"
+    mn, mx = min(prices), max(prices)
+    rng = mx - mn or 1
+    result = ""
+    step = max(1, len(prices) // width)
+    for i in range(0, len(prices), step):
+        idx = int((prices[i] - mn) / rng * (len(blocks) - 1))
+        result += blocks[idx]
+    return result[:width]
+
+
+def detect_ollama_models(ollama_url: str = "http://localhost:11434") -> list:
+    """Query Ollama /api/tags and return list of available model names.
+
+    Always bypasses HTTP_PROXY so localhost is reached directly even when a
+    system proxy (VPN / clash / surge) is active.
+    """
+    import urllib.request
+    # Force direct connection — bypass any HTTP_PROXY / HTTPS_PROXY env vars
+    _opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+    try:
+        with _opener.open(f"{ollama_url}/api/tags", timeout=5) as r:
+            data = json.loads(r.read())
+        return [m["name"] for m in data.get("models", [])]
+    except Exception:
+        # Also try 127.0.0.1 if hostname is "localhost" (IPv6 resolution fallback)
+        if "localhost" in ollama_url:
+            try:
+                fallback = ollama_url.replace("localhost", "127.0.0.1")
+                with _opener.open(f"{fallback}/api/tags", timeout=5) as r:
+                    data = json.loads(r.read())
+                return [m["name"] for m in data.get("models", [])]
+            except Exception:
+                pass
+        return []
+
+
+def detect_ollama_models_rich(ollama_url: str = "http://localhost:11434") -> tuple:
+    """Return (models_list, error_str) where each entry in models_list is a dict:
+        {"name": str, "size_label": str, "family": str, "quant": str,
+         "execution": "local" | "remote", "remote_host": str,
+         "context_window": int, "capabilities": list[str]}
+    error_str is None on success, or a short human-readable reason on failure.
+    """
+    import urllib.request
+    _opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+    def _try(url: str):
+        with _opener.open(f"{url}/api/tags", timeout=5) as r:
+            return json.loads(r.read())
+
+    data = None
+    last_err = None
+    for u in [ollama_url] + ([ollama_url.replace("localhost", "127.0.0.1")]
+                              if "localhost" in ollama_url else []):
+        try:
+            data = _try(u)
+            break
+        except OSError as e:
+            last_err = str(e)
+        except Exception as e:
+            last_err = str(e)
+
+    if data is None:
+        return [], last_err or "connection failed"
+
+    results = []
+    for m in data.get("models", []):
+        det  = m.get("details", {})
+        size = det.get("parameter_size", "")
+        fam  = det.get("family", "")
+        qnt  = det.get("quantization_level", "")
+        results.append({
+            "name":       m["name"],
+            "size_label": size,    # e.g. "1.5B", "7B", "671.0B"
+            "family":     fam,     # e.g. "qwen2", "deepseek2"
+            "quant":      qnt,     # e.g. "Q4_K_M", "MXFP4"
+            "execution":  "remote" if m.get("remote_host") else "local",
+            "remote_model": m.get("remote_model", ""),
+            "remote_host": m.get("remote_host", ""),
+            "context_window": int(det.get("context_length") or 0),
+            "capabilities": list(m.get("capabilities") or []),
+        })
+    return results, None