aria-code 4.1.3__py3-none-any.whl

apps/cli/config_paths.py

@@ -0,0 +1,70 @@
+"""Shared config path resolution for Aria CLI components."""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class AriaConfigPaths:
+    config_dir: Path
+    config_file: Path
+    history_file: Path
+    sessions_dir: Path
+    providers_file: Path
+    hooks_file: Path
+    user_output_root: Path
+    user_generated_dir: Path
+    user_projects_dir: Path
+
+
+def resolve_config_dir() -> Path:
+    """Resolve the user config directory with stable precedence."""
+    if "ARIA_HOME" in os.environ:
+        return Path(os.environ["ARIA_HOME"]).expanduser()
+    legacy = Path.home() / ".arthera"
+    if legacy.exists():
+        return legacy
+    return Path.home() / ".aria-code"
+
+
+def resolve_user_output_root() -> Path:
+    """Resolve the per-user output root for generated code and user artifacts."""
+    configured = os.getenv("ARIA_USER_OUTPUT_ROOT")
+    if configured:
+        return Path(configured).expanduser()
+    return Path.home() / "Documents" / "Aria Code"
+
+
+def resolve_paths(config_dir: Optional[Path] = None) -> AriaConfigPaths:
+    root = Path(config_dir).expanduser() if config_dir else resolve_config_dir()
+    user_output_root = resolve_user_output_root()
+    return AriaConfigPaths(
+        config_dir=root,
+        config_file=root / "config.json",
+        history_file=root / "history",
+        sessions_dir=root / "sessions",
+        providers_file=root / "providers.json",
+        hooks_file=root / "hooks.json",
+        user_output_root=user_output_root,
+        user_generated_dir=user_output_root / "generated",
+        user_projects_dir=user_output_root / "projects",
+    )
+
+
+def config_snapshot(config_dir: Optional[Path] = None) -> dict[str, str]:
+    """Return a JSON-serializable snapshot of resolved config paths."""
+    paths = resolve_paths(config_dir)
+    return {
+        "config_dir": str(paths.config_dir),
+        "config_file": str(paths.config_file),
+        "history_file": str(paths.history_file),
+        "sessions_dir": str(paths.sessions_dir),
+        "providers_file": str(paths.providers_file),
+        "hooks_file": str(paths.hooks_file),
+        "user_output_root": str(paths.user_output_root),
+        "user_generated_dir": str(paths.user_generated_dir),
+        "user_projects_dir": str(paths.user_projects_dir),
+    }

apps/cli/config_store.py

@@ -0,0 +1,61 @@
+"""Persistent CLI configuration loading and saving."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+
+from apps.cli.config_paths import AriaConfigPaths
+
+
+STALE_ARIA_MODEL_PREFIXES = ("aria-opus", "aria-prelude", "aria-sonata:3", "aria-sonata:4")
+
+
+def load_cli_config(
+    paths: AriaConfigPaths,
+    defaults: dict,
+    *,
+    sync_policy: Callable[[dict], None] | None = None,
+) -> dict:
+    """Load config.json and merge with defaults."""
+    paths.config_dir.mkdir(parents=True, exist_ok=True)
+    paths.sessions_dir.mkdir(parents=True, exist_ok=True)
+    if paths.config_file.exists():
+        try:
+            saved = json.loads(paths.config_file.read_text(encoding="utf-8"))
+            merged = {**defaults, **saved}
+            saved_model = merged.get("model", "")
+            if any(saved_model.startswith(prefix) for prefix in STALE_ARIA_MODEL_PREFIXES):
+                merged["model"] = defaults["model"]
+            if not merged.get("ui_lang"):
+                try:
+                    from apps.cli.i18n import detect_system_lang
+
+                    merged["ui_lang"] = detect_system_lang()
+                except Exception:
+                    merged["ui_lang"] = "en"
+            if sync_policy:
+                sync_policy(merged)
+            return merged
+        except Exception:
+            pass
+
+    cfg = dict(defaults)
+    try:
+        from apps.cli.i18n import auto_select_model, detect_system_lang
+
+        cfg["ui_lang"] = detect_system_lang()
+        ollama_url = cfg.get("ollama_url", "http://localhost:11434")
+        cfg["model"] = auto_select_model(ollama_url, fallback=defaults["model"])
+    except Exception:
+        cfg["ui_lang"] = "en"
+    if sync_policy:
+        sync_policy(cfg)
+    return cfg
+
+
+def save_cli_config(paths: AriaConfigPaths, cfg: dict) -> None:
+    paths.config_dir.mkdir(parents=True, exist_ok=True)
+    exclude = {"conversation_history"}
+    payload = {key: value for key, value in cfg.items() if key not in exclude}
+    paths.config_file.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")

apps/cli/deterministic.py

@@ -0,0 +1,122 @@
+"""Shared deterministic routing for Aria agent entrypoints.
+
+This module is intentionally UI-free.  The legacy CLI, future daemon/webhook
+entrypoints, and the public SDK can all use the same routing order without
+importing the terminal implementation from ``aria_cli.py``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from apps.cli.handlers.broker_handlers import handle_broker_query
+from apps.cli.handlers.chart_handlers import handle_stock_chart_analysis
+from apps.cli.handlers.market_handlers import (
+    _try_handle_market_overview,
+    _try_handle_market_snapshot_analysis,
+)
+from apps.cli.handlers.realty_handlers import handle_realty_query
+from apps.cli.handlers.strategy_advice import handle_strategy_advice
+from apps.cli.utils.market_detect import (
+    _CN_CITIES,
+    _INTL_CITIES,
+    _extract_market_symbol,
+    _is_broker_intent,
+    _is_realty_query,
+    _is_stock_chart_analysis_request,
+)
+
+
+BrokerRegistryFactory = Callable[[], Any]
+
+
+def _missing_broker_registry() -> None:
+    return None
+
+
+@dataclass(frozen=True)
+class DeterministicRouterConfig:
+    """Configuration for deterministic routing outside the model loop."""
+
+    model_has_tools: bool = True
+    has_brokers: bool = False
+    get_broker_registry: BrokerRegistryFactory | None = None
+
+
+def _handle_broker_query(message: str, config: DeterministicRouterConfig) -> dict:
+    return handle_broker_query(
+        message,
+        has_brokers=config.has_brokers,
+        is_broker_intent=_is_broker_intent,
+        get_broker_registry=config.get_broker_registry or _missing_broker_registry,
+    )
+
+
+def _handle_realty_query(message: str) -> dict:
+    return handle_realty_query(
+        message,
+        is_realty_query=_is_realty_query,
+        cn_cities=_CN_CITIES,
+        intl_cities=_INTL_CITIES,
+    )
+
+
+def _handle_stock_chart_analysis(message: str) -> dict:
+    return handle_stock_chart_analysis(
+        message,
+        is_chart_request=_is_stock_chart_analysis_request,
+        extract_symbol=_extract_market_symbol,
+    )
+
+
+def run_deterministic_chain(
+    message: str,
+    *,
+    model_has_tools: bool,
+    history: list | None = None,
+    has_brokers: bool = False,
+    get_broker_registry: BrokerRegistryFactory | None = None,
+) -> dict:
+    """Run the deterministic routing chain used before LLM fallback.
+
+    Order matters:
+    - broker account reads are only used when the model cannot call tools;
+    - realty must run before market parsing, so housing questions do not inherit
+      a ticker;
+    - chart requests run before snapshots;
+    - whole-market overview runs before single-symbol snapshot parsing, so
+      "分析A股" is treated as the A-share market instead of ticker ``A``.
+    """
+
+    config = DeterministicRouterConfig(
+        model_has_tools=model_has_tools,
+        has_brokers=has_brokers,
+        get_broker_registry=get_broker_registry,
+    )
+
+    deterministic: dict = {"success": False}
+    if not config.model_has_tools:
+        deterministic = _handle_broker_query(message, config)
+
+    for handler in (
+        handle_strategy_advice,
+        _handle_realty_query,
+        _handle_stock_chart_analysis,
+        _try_handle_market_overview,
+    ):
+        if deterministic.get("success"):
+            break
+        deterministic = handler(message)
+
+    if not deterministic.get("success"):
+        deterministic = _try_handle_market_snapshot_analysis(message, history=history)
+
+    return deterministic
+
+
+__all__ = [
+    "BrokerRegistryFactory",
+    "DeterministicRouterConfig",
+    "run_deterministic_chain",
+]

apps/cli/direct.py

@@ -0,0 +1,48 @@
+"""Direct command dispatcher for non-interactive CLI entrypoints."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any
+
+from apps.cli.commands.catalog import DIRECT_COMMAND_MAP, WATCHABLE_DIRECT_COMMANDS
+
+
+def is_watchable_direct_command(command: str) -> bool:
+    return command.strip().lower() in WATCHABLE_DIRECT_COMMANDS
+
+
+async def dispatch_direct_command(
+    terminal: Any,
+    command: str,
+    command_args: str = "",
+    *,
+    json_output: bool = False,
+    fmt: str = "table",
+    output_file: str | None = None,
+    quiet: bool = False,
+) -> bool:
+    """Dispatch a direct CLI command.
+
+    Returns True when the command was handled by a known direct command handler.
+    Unknown direct commands fall back to the normal prompt path and return False.
+    """
+
+    cmd = command.strip().lower()
+    spec = DIRECT_COMMAND_MAP.get(cmd)
+    if spec is None:
+        await terminal.run_prompt(
+            f"{command} {command_args}".strip(),
+            json_output=json_output,
+            fmt=fmt,
+            output_file=output_file,
+            quiet=quiet,
+        )
+        return False
+
+    handler = getattr(terminal.commands, spec.method_name)
+    result = handler(command_args)
+    if inspect.isawaitable(result):
+        await result
+    return True
+

apps/cli/github_app_auth.py

@@ -0,0 +1,135 @@
+"""GitHub App authentication — generates installation tokens for Aria Code[bot].
+
+Usage:
+    from apps.cli.github_app_auth import get_installation_token, get_aria_git_url
+
+    token = get_installation_token()          # raises if not configured
+    url   = get_aria_git_url("artherahq/aria-code", token)
+    # git push with url as remote
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+ARIA_APP_ID    = int(os.getenv("ARIA_GITHUB_APP_ID", "4114189"))
+ARIA_APP_SLUG  = os.getenv("ARIA_GITHUB_APP_SLUG", "aria-code")
+
+# Search order for private key
+_PEM_SEARCH = [
+    os.getenv("ARIA_GITHUB_APP_PEM", ""),
+    os.path.expanduser("~/.config/aria-code/github-app.pem"),
+    os.path.expanduser("~/.aria-code/github-app.pem"),
+    "github-app.pem",
+]
+
+# noreply email GitHub uses for bot commits
+# Format: {app_id}+{app_slug}[bot]@users.noreply.github.com
+ARIA_BOT_EMAIL = f"{ARIA_APP_ID}+{ARIA_APP_SLUG}[bot]@users.noreply.github.com"
+ARIA_BOT_NAME  = "Aria Code"
+
+# GitHub user account for Aria — shows up in Contributors
+ARIA_GITHUB_LOGIN = os.getenv("ARIA_GITHUB_LOGIN", "ariaaii")
+ARIA_GITHUB_EMAIL = os.getenv("ARIA_GITHUB_EMAIL", "support@arthera.finance")
+
+
+def _find_pem() -> str:
+    for path in _PEM_SEARCH:
+        if path and os.path.isfile(path):
+            return path
+    raise FileNotFoundError(
+        "GitHub App private key not found. "
+        "Set ARIA_GITHUB_APP_PEM=/path/to/key.pem or place it at "
+        "~/.config/aria-code/github-app.pem"
+    )
+
+
+def _b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
+
+
+def _make_jwt(pem_path: str, app_id: int) -> str:
+    """Create a signed JWT using RSA-SHA256 (pure stdlib + cryptography)."""
+    try:
+        from cryptography.hazmat.primitives import hashes, serialization
+        from cryptography.hazmat.primitives.asymmetric import padding
+        from cryptography.hazmat.backends import default_backend
+    except ImportError:
+        raise ImportError(
+            "Install cryptography: pip install cryptography"
+        )
+
+    with open(pem_path, "rb") as f:
+        private_key = serialization.load_pem_private_key(f.read(), password=None, backend=default_backend())
+
+    now = int(time.time())
+    header  = _b64url(json.dumps({"alg": "RS256", "typ": "JWT"}).encode())
+    payload = _b64url(json.dumps({"iat": now - 60, "exp": now + 540, "iss": str(app_id)}).encode())
+    signing_input = f"{header}.{payload}".encode()
+    signature = _b64url(private_key.sign(signing_input, padding.PKCS1v15(), hashes.SHA256()))
+    return f"{header}.{payload}.{signature}"
+
+
+def _gh_api(path: str, token: str, *, method: str = "GET") -> dict:
+    url = f"https://api.github.com{path}"
+    req = urllib.request.Request(
+        url,
+        method=method,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=15) as resp:
+        return json.loads(resp.read())
+
+
+def get_installation_token(owner: str = "artherahq") -> str:
+    """Return a short-lived installation token (valid ~1 hour)."""
+    pem   = _find_pem()
+    jwt   = _make_jwt(pem, ARIA_APP_ID)
+
+    # Find installation for owner
+    installations = _gh_api("/app/installations", jwt)
+    installation_id = None
+    for inst in installations:
+        if inst.get("account", {}).get("login", "").lower() == owner.lower():
+            installation_id = inst["id"]
+            break
+    if installation_id is None:
+        accts = [i.get("account", {}).get("login") for i in installations]
+        raise RuntimeError(
+            f"Aria Code GitHub App not installed for '{owner}'. "
+            f"Installed accounts: {accts}. "
+            f"Go to https://github.com/apps/aria-code and install it."
+        )
+
+    # Exchange for installation token
+    result = _gh_api(f"/app/installations/{installation_id}/access_tokens", jwt, method="POST")
+    token = result.get("token")
+    if not token:
+        raise RuntimeError(f"Failed to get installation token: {result}")
+    return token
+
+
+def get_aria_git_url(repo: str, token: str) -> str:
+    """Return an authenticated HTTPS remote URL using the installation token."""
+    return f"https://x-access-token:{token}@github.com/{repo}.git"
+
+
+def aria_bot_env() -> dict[str, str]:
+    """Env vars that make git commit as Aria Code[bot]."""
+    return {
+        "GIT_AUTHOR_NAME":     ARIA_BOT_NAME,
+        "GIT_AUTHOR_EMAIL":    ARIA_BOT_EMAIL,
+        "GIT_COMMITTER_NAME":  ARIA_BOT_NAME,
+        "GIT_COMMITTER_EMAIL": ARIA_BOT_EMAIL,
+    }

apps/cli/handlers/__init__.py

@@ -0,0 +1,11 @@
+"""apps/cli/handlers — deterministic pre-LLM response handlers extracted from aria_cli.py."""
+from .broker_handlers import handle_broker_query
+from .realty_handlers import handle_realty_query
+from .chart_handlers import handle_stock_chart_analysis_direct, handle_stock_chart_analysis
+
+__all__ = [
+    "handle_broker_query",
+    "handle_realty_query",
+    "handle_stock_chart_analysis_direct",
+    "handle_stock_chart_analysis",
+]

apps/cli/handlers/broker_handlers.py

@@ -0,0 +1,122 @@
+"""Deterministic broker data handler extracted from aria_cli.py."""
+from __future__ import annotations
+
+from typing import Callable
+
+
+def handle_broker_query(
+    message: str,
+    *,
+    has_brokers: bool,
+    is_broker_intent: Callable[[str], bool],
+    get_broker_registry: Callable,
+) -> dict:
+    """Deterministic broker data path for models without reliable tool_calls.
+
+    When the user asks about their portfolio/account and no tool-call model is
+    available, fetch the data directly and return a pre-formatted markdown
+    response — same data the LLM tool would have provided.
+    """
+    if not has_brokers:
+        return {"success": False, "error": "brokers_not_available"}
+    if not is_broker_intent(message):
+        return {"success": False, "error": "not_broker_query"}
+
+    try:
+        _reg = get_broker_registry()
+        broker = _reg.active()
+        if not broker or not broker.is_connected:
+            return {
+                "success": True,
+                "response": (
+                    "## 账户未连接\n\n"
+                    "当前没有已连接的券商账户。\n\n"
+                    "请运行 `/broker connect <id>` 或 `/broker list` 查看可用账户。"
+                ),
+                "tools_used": ["broker_query"],
+            }
+
+        _msg_lower = message.lower()
+        lines = [f"## {broker.label} 账户信息\n"]
+
+        _want_positions = any(k in _msg_lower for k in (
+            "持仓", "position", "portfolio", "仓位", "我的股票", "持有",
+        ))
+        _want_orders = any(k in _msg_lower for k in (
+            "订单", "order", "委托", "成交", "交易记录",
+        ))
+        _want_account = any(k in _msg_lower for k in (
+            "余额", "balance", "账户", "account", "资金", "cash", "净值",
+        ))
+        if not (_want_positions or _want_orders or _want_account):
+            _want_account = True
+            _want_positions = True
+
+        if _want_account:
+            try:
+                acct = broker.account_info()
+                lines.append("### 资金概况")
+                lines.append(f"- **总资产**: {acct.currency} {acct.total_assets:,.2f}")
+                lines.append(f"- **可用资金**: {acct.currency} {acct.available_cash:,.2f}")
+                if acct.market_value is not None:
+                    lines.append(f"- **持仓市值**: {acct.currency} {acct.market_value:,.2f}")
+                if acct.unrealized_pnl is not None:
+                    _pnl_sign = "+" if acct.unrealized_pnl >= 0 else ""
+                    lines.append(f"- **浮动盈亏**: {_pnl_sign}{acct.unrealized_pnl:,.2f}")
+                lines.append("")
+            except Exception as _ae:
+                lines.append(f"*获取账户信息失败: {_ae}*\n")
+
+        if _want_positions:
+            try:
+                positions = broker.positions()
+                if positions:
+                    lines.append("### 当前持仓")
+                    lines.append("| 代码 | 名称 | 数量 | 成本 | 现价 | 盈亏% |")
+                    lines.append("|------|------|------|------|------|-------|")
+                    for p in positions[:15]:
+                        _pct = (
+                            f"{p.unrealized_pnl_pct:+.2f}%"
+                            if p.unrealized_pnl_pct is not None else "N/A"
+                        )
+                        _cost = f"{p.avg_cost:.2f}" if p.avg_cost is not None else "N/A"
+                        _price = f"{p.current_price:.2f}" if p.current_price is not None else "N/A"
+                        lines.append(
+                            f"| {p.symbol} | {p.name or '-'} | {p.qty:,} "
+                            f"| {_cost} | {_price} | {_pct} |"
+                        )
+                    if len(positions) > 15:
+                        lines.append(f"\n*共 {len(positions)} 只持仓，仅显示前 15 只*")
+                else:
+                    lines.append("*当前无持仓*")
+                lines.append("")
+            except Exception as _pe:
+                lines.append(f"*获取持仓失败: {_pe}*\n")
+
+        if _want_orders:
+            try:
+                orders = broker.orders()
+                if orders:
+                    lines.append("### 最近委托")
+                    lines.append("| 代码 | 方向 | 数量 | 价格 | 状态 |")
+                    lines.append("|------|------|------|------|------|")
+                    for o in orders[:10]:
+                        _price_str = f"{o.price:.2f}" if o.price else "市价"
+                        lines.append(
+                            f"| {o.symbol} | {'买入' if o.side=='buy' else '卖出'} "
+                            f"| {o.qty:,} | {_price_str} | {o.status} |"
+                        )
+                else:
+                    lines.append("*暂无委托记录*")
+                lines.append("")
+            except Exception as _oe:
+                lines.append(f"*获取委托记录失败: {_oe}*\n")
+
+        lines.append("*以上数据来自券商 API，不构成投资建议*")
+        return {
+            "success": True,
+            "response": "\n".join(lines),
+            "tools_used": ["broker_query"],
+        }
+    except Exception as exc:
+        return {"success": False, "error": str(exc)}