aria-code 4.1.3__py3-none-any.whl

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(f"- `/realty rent` — 租金收益率计算")
+    lines.append(f"- `/realty reit` — REIT 市场数据")
+
+    return {
+        "success": True,
+        "response": "\n".join(lines),
+        "tools_used": ["realty_query"],
+    }

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,
+    }

apps/cli/hooks.py

@@ -0,0 +1,180 @@
+"""Aria Code lifecycle hooks — JSON-configurable, shell-executable.
+
+Config file: ~/.arthera/hooks.json
+Project-local override: .aria/hooks.json  (takes precedence)
+
+Schema
+------
+{
+  "PreToolUse":   [{"tool": "run_command", "command": "echo $ARIA_TOOL"}],
+  "PostToolUse":  [{"command": "notify-send 'done'"}],
+  "ResponseDone": [{"command": "afplay /System/Sounds/Glass.aiff"}],
+  "SessionStart": [{"command": "echo starting $ARIA_SESSION"}],
+  "SessionEnd":   [{"command": "echo ended"}]
+}
+
+Each hook entry:
+  command  — shell command to execute (required)
+  tool     — if set, only fires when tool name matches (PreToolUse / PostToolUse)
+  timeout  — seconds before the hook is killed (default 10)
+  blocking — if true AND exit code != 0, execution is blocked (PreToolUse only)
+
+Env vars injected into every hook:
+  ARIA_EVENT        — hook event name
+  ARIA_TOOL         — tool name (Pre/PostToolUse only)
+  ARIA_TOOL_PARAMS  — JSON-encoded params (Pre/PostToolUse only)
+  ARIA_RESULT       — JSON-encoded result (PostToolUse only)
+  ARIA_RESPONSE     — first 500 chars of response (ResponseDone)
+  ARIA_SESSION      — session ID
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from apps.cli.config_paths import resolve_config_dir
+
+logger = logging.getLogger(__name__)
+
+_CONFIG_DIR = resolve_config_dir()
+_GLOBAL_HOOKS_FILE = _CONFIG_DIR / "hooks.json"
+_LOCAL_HOOKS_FILE = Path.cwd() / ".aria" / "hooks.json"
+
+_VALID_EVENTS = frozenset([
+    "PreToolUse", "PostToolUse",
+    "ResponseDone",
+    "SessionStart", "SessionEnd",
+])
+
+
+def load_hooks() -> dict:
+    """Load and merge global + project-local hooks config."""
+    merged: dict[str, list] = {e: [] for e in _VALID_EVENTS}
+
+    for path in (_GLOBAL_HOOKS_FILE, _LOCAL_HOOKS_FILE):
+        if path.exists():
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                for event, entries in data.items():
+                    if event in _VALID_EVENTS and isinstance(entries, list):
+                        merged[event].extend(entries)
+            except Exception as exc:
+                logger.debug("hooks.json parse error (%s): %s", path, exc)
+
+    return merged
+
+
+def fire(
+    event: str,
+    *,
+    tool: Optional[str] = None,
+    params: Optional[dict] = None,
+    result: Optional[dict] = None,
+    response: str = "",
+    session_id: str = "",
+    hooks: Optional[dict] = None,
+) -> bool:
+    """Fire all matching hooks for an event.
+
+    Returns False if any *blocking* PreToolUse hook exits non-zero
+    (meaning the tool call should be suppressed). Returns True otherwise.
+    """
+    if hooks is None:
+        hooks = load_hooks()
+
+    entries = hooks.get(event, [])
+    if not entries:
+        return True
+
+    base_env = dict(os.environ)
+    base_env["ARIA_EVENT"] = event
+    base_env["ARIA_SESSION"] = session_id or ""
+    if tool:
+        base_env["ARIA_TOOL"] = tool
+    if params is not None:
+        base_env["ARIA_TOOL_PARAMS"] = json.dumps(params, ensure_ascii=False)[:2000]
+    if result is not None:
+        base_env["ARIA_RESULT"] = json.dumps(result, ensure_ascii=False)[:2000]
+    if response:
+        base_env["ARIA_RESPONSE"] = response[:500]
+
+    blocked = False
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        cmd = entry.get("command", "").strip()
+        if not cmd:
+            continue
+
+        # Tool filter: skip if hook is scoped to a different tool
+        if entry.get("tool") and tool and entry["tool"] != tool:
+            continue
+
+        timeout = int(entry.get("timeout", 10))
+        is_blocking = bool(entry.get("blocking", False))
+
+        try:
+            proc = subprocess.run(
+                cmd,
+                shell=True,
+                env=base_env,
+                timeout=timeout,
+                capture_output=True,
+                text=True,
+            )
+            if is_blocking and proc.returncode != 0 and event == "PreToolUse":
+                logger.info(
+                    "Blocking hook vetoed tool '%s': exit %d — %s",
+                    tool, proc.returncode, proc.stderr[:120],
+                )
+                blocked = True
+        except subprocess.TimeoutExpired:
+            logger.debug("Hook timed out after %ds: %s", timeout, cmd[:60])
+        except Exception as exc:
+            logger.debug("Hook error: %s", exc)
+
+    return not blocked
+
+
+def list_hooks() -> list[dict]:
+    """Return a flat list of configured hooks for display."""
+    hooks = load_hooks()
+    rows = []
+    for event, entries in hooks.items():
+        for entry in entries:
+            if isinstance(entry, dict) and entry.get("command"):
+                rows.append({
+                    "event": event,
+                    "tool": entry.get("tool", "*"),
+                    "command": entry["command"][:80],
+                    "blocking": entry.get("blocking", False),
+                    "timeout": entry.get("timeout", 10),
+                })
+    return rows
+
+
+def hooks_file_path(scope: str = "global") -> Path:
+    """Return the hooks.json path for a given scope."""
+    if scope == "local":
+        return Path.cwd() / ".aria" / "hooks.json"
+    return _GLOBAL_HOOKS_FILE
+
+
+def create_example_hooks(path: Path) -> None:
+    """Write an annotated example hooks.json if it doesn't exist."""
+    if path.exists():
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    example = {
+        "_comment": "Aria Code hooks — https://aria.code/docs/hooks",
+        "PreToolUse": [],
+        "PostToolUse": [],
+        "ResponseDone": [],
+        "SessionStart": [],
+        "SessionEnd": [],
+    }
+    path.write_text(json.dumps(example, indent=2, ensure_ascii=False), encoding="utf-8")

apps/cli/i18n.py

@@ -0,0 +1,284 @@
+"""i18n.py — System language detection and UI string translations for Aria Code.
+
+Priority order for UI language:
+  1. config["ui_lang"]  (user explicitly set via /config set ui_lang=zh)
+  2. OS locale at first-run  (written into config automatically)
+  3. Fallback: "en"
+
+Supported languages: "zh" (Simplified Chinese), "en" (English)
+Future: "ja", "ko" — extend STRINGS dict below.
+"""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# String catalogue
+# ---------------------------------------------------------------------------
+
+STRINGS: dict[str, dict[str, str]] = {
+    # Banner labels
+    "local_first_agent": {
+        "zh": "本地优先智能体",
+        "en": "local-first agent",
+    },
+    "model": {
+        "zh": "模型",
+        "en": "model",
+    },
+    "workspace": {
+        "zh": "工作区",
+        "en": "workspace",
+    },
+    "mode": {
+        "zh": "模式",
+        "en": "mode",
+    },
+    "status": {
+        "zh": "状态",
+        "en": "status",
+    },
+    "tools": {
+        "zh": "工具",
+        "en": "tools",
+    },
+    "skills": {
+        "zh": "技能",
+        "en": "skills",
+    },
+    "quant": {
+        "zh": "量化",
+        "en": "quant",
+    },
+    # Status labels
+    "sharing_on": {
+        "zh": "数据共享",
+        "en": "sharing on",
+    },
+    "local_only": {
+        "zh": "纯本地",
+        "en": "local-only",
+    },
+    "cloud": {
+        "zh": "云端",
+        "en": "cloud",
+    },
+    "local": {
+        "zh": "本地",
+        "en": "local",
+    },
+    "lite": {
+        "zh": "轻量",
+        "en": "lite",
+    },
+    "ollama_online": {
+        "zh": "Ollama 在线",
+        "en": "Ollama online",
+    },
+    "ollama_offline": {
+        "zh": "Ollama 离线",
+        "en": "Ollama offline",
+    },
+    "cloud_connected": {
+        "zh": "云端已连接",
+        "en": "cloud ✓",
+    },
+    "model_singular": {
+        "zh": "个模型",
+        "en": "model",
+    },
+    "model_plural": {
+        "zh": "个模型",
+        "en": "models",
+    },
+    # Hint line
+    "try": {
+        "zh": "试试",
+        "en": "try",
+    },
+    # Model picker
+    "select_model": {
+        "zh": "选择模型",
+        "en": "Select Model",
+    },
+    "installed": {
+        "zh": "已安装",
+        "en": "installed",
+    },
+    "not_installed": {
+        "zh": "未安装",
+        "en": "not installed",
+    },
+    "cancelled": {
+        "zh": "已取消",
+        "en": "Cancelled",
+    },
+    "no_change": {
+        "zh": "未更改",
+        "en": "No change",
+    },
+    "community_models": {
+        "zh": "社区模型 (Ollama)",
+        "en": "Community (Ollama)",
+    },
+    "ollama_unreachable": {
+        "zh": "Ollama 无法连接",
+        "en": "Ollama unreachable",
+    },
+    "switch_model_hint": {
+        "zh": "使用 /model <id> 切换模型",
+        "en": "Use /model <id> to switch",
+    },
+    "current": {
+        "zh": "当前",
+        "en": "current",
+    },
+    # Permission / mode labels
+    "network_on": {
+        "zh": "网络开",
+        "en": "network on",
+    },
+    "network_off": {
+        "zh": "网络关",
+        "en": "network off",
+    },
+    "privacy": {
+        "zh": "隐私",
+        "en": "privacy",
+    },
+    # Setup wizard
+    "detecting_lang": {
+        "zh": "检测到系统语言：中文",
+        "en": "Detected system language: English",
+    },
+    "first_run_welcome": {
+        "zh": "欢迎使用 Aria Code！首次运行，正在自动配置...",
+        "en": "Welcome to Aria Code! First run — auto-configuring...",
+    },
+    "auto_model_selected": {
+        "zh": "已自动选择本地模型：",
+        "en": "Auto-selected local model: ",
+    },
+    "no_ollama_models": {
+        "zh": "未发现本地模型，使用默认配置",
+        "en": "No local models found, using default config",
+    },
+    # Thinking mode
+    "thinking_mode": {
+        "zh": "思考模式",
+        "en": "Thinking Mode",
+    },
+    # Misc
+    "tip": {
+        "zh": "提示",
+        "en": "tip",
+    },
+    "auto_matched": {
+        "zh": "自动匹配",
+        "en": "auto-matched",
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+def detect_system_lang() -> str:
+    """Detect OS language. Returns 'zh' for Chinese systems, 'en' for everything else.
+
+    Checks (in order): $LANGUAGE, $LANG, $LC_ALL, $LC_MESSAGES, Python locale module.
+    Treats zh_CN, zh_TW, zh_HK, zh_SG as 'zh'.
+    """
+    for var in ("LANGUAGE", "LANG", "LC_ALL", "LC_MESSAGES"):
+        raw = os.environ.get(var, "").strip()
+        if not raw or raw in ("C", "POSIX", "C.UTF-8"):
+            continue
+        # LANGUAGE may be colon-separated list: zh_CN:en
+        code = raw.split(":")[0].split(".")[0].split("_")[0].lower()
+        if code == "zh":
+            return "zh"
+        if code in ("en", "fr", "de", "es", "pt", "ja", "ko", "ru", "ar"):
+            return code if code in ("ja", "ko") else "en"
+
+    # Fallback: Python locale module (works on macOS/Windows when env vars absent)
+    try:
+        import locale as _locale
+        lang_code, _ = _locale.getdefaultlocale()
+        if lang_code:
+            prefix = lang_code.split("_")[0].lower()
+            if prefix == "zh":
+                return "zh"
+            if prefix in ("ja", "ko"):
+                return prefix
+    except Exception:
+        pass
+
+    return "en"
+
+
+def get_ui_lang(config: Optional[dict] = None) -> str:
+    """Return effective UI language.
+
+    1. config["ui_lang"] if explicitly set
+    2. detect_system_lang()
+    """
+    if config:
+        saved = config.get("ui_lang", "")
+        if saved in STRINGS.get("model", {}):  # valid lang code
+            return saved
+    return detect_system_lang()
+
+
+def t(key: str, lang: Optional[str] = None, config: Optional[dict] = None) -> str:
+    """Translate a UI key to the given language (or auto-detect).
+
+    Falls back to 'en' if key/lang not found.
+    """
+    if lang is None:
+        lang = get_ui_lang(config)
+    entry = STRINGS.get(key, {})
+    return entry.get(lang) or entry.get("en") or key
+
+
+# ---------------------------------------------------------------------------
+# Ollama model helpers (used by load_config on first run)
+# ---------------------------------------------------------------------------
+
+_MODEL_PRIORITY = [
+    "qwen2.5:7b",
+    "qwen2.5-coder:7b",
+    "deepseek-r1:7b",
+    "qwen2.5:3b",
+    "qwen2.5-coder:3b",
+    "llama3.2:3b",
+    "mistral:7b",
+    "qwen2.5-coder:1.5b",
+    "qwen2.5:1.5b",
+    "llama3.2:1b",
+]
+
+
+def auto_select_model(ollama_url: str = "http://localhost:11434",
+                      fallback: str = "qwen2.5-coder:1.5b") -> str:
+    """Query Ollama and return the best locally available model.
+
+    Returns *fallback* when Ollama is unreachable or no models are installed.
+    """
+    try:
+        import urllib.request as _ur
+        import json as _json
+        with _ur.urlopen(f"{ollama_url}/api/tags", timeout=3) as resp:
+            data = _json.loads(resp.read())
+        installed = {m["name"] for m in data.get("models", [])}
+        if not installed:
+            return fallback
+        for pref in _MODEL_PRIORITY:
+            if pref in installed:
+                return pref
+        # Return alphabetically first installed model
+        return sorted(installed)[0]
+    except Exception:
+        return fallback