aria-code 0.52.0__py3-none-any.whl

aria_code/apps/cli/football_reports.py

@@ -0,0 +1,231 @@
+"""足球赛事报表渲染 —— 从 aria_cli.py 抽出的第一块。
+
+这四个函数原本在 aria_cli.py 末尾（8512-8715 行）。它们几乎完全自包含：
+rich 组件和 football_data_client 都是函数内 import，唯一的外部依赖是模块级
+的 ``console``。
+
+⚠️ 调用方式的约束（拆分本文件时最容易踩坏的地方）：
+``apps/cli/commands/market_cmds.py`` 是一个 mixin，它用**裸名字**调用
+``_football_standings(...)`` —— 这只有在 aria_cli 通过 ``_rebind_mixin_globals``
+把 mixin 方法的 ``__globals__`` 指向 aria_cli 命名空间时才成立。所以本模块
+**不能**只是被 import，必须由 aria_cli 用 ``_rebind_module_function_globals``
+把这些函数重新绑定回它自己的 globals，``console`` 和裸名调用才都能解析。
+这跟 aria_cli 对 ``apps.cli.tool_executor`` 的处理是同一套既有机制。
+
+直接 ``from apps.cli.football_reports import _football_standings`` 再调用会
+在运行期 NameError（找不到 console）——那是预期行为，不是缺陷：状态注入还
+没做到每个调用点，兼容边界仍留在 aria_cli。
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "_football_standings",
+    "_football_fixtures",
+    "_football_team",
+    "_football_h2h",
+]
+
+
+def _football_standings(league: str) -> None:
+    from rich.table import Table
+    from rich import box as rich_box
+    from rich.panel import Panel
+    try:
+        from football_data_client import get_standings, LEAGUE_NAMES, _resolve_league
+    except ImportError:
+        console.print("[red]football_data_client.py 未找到[/red]")
+        return
+
+    console.print(f"[dim]获取 {league.upper()} 积分榜…[/dim]")
+    data = get_standings(league)
+    if not data:
+        comp = _resolve_league(league)
+        console.print(
+            "[yellow]无法获取数据。请设置 FOOTBALL_DATA_API_KEY:[/yellow]\n"
+            "  1. 访问 football-data.org 免费注册\n"
+            "  2. 在 ~/.aria/.env 中添加:\n"
+            "     [cyan]FOOTBALL_DATA_API_KEY=your_key_here[/cyan]"
+        )
+        return
+
+    t = Table(
+        title=f"[bold]{data['league_name']}[/bold]  {data['season_start'][:4]}/{data['season_end'][:4]}",
+        box=rich_box.SIMPLE,
+        show_header=True,
+        header_style="bold",
+        padding=(0, 1),
+    )
+    t.add_column("#",    width=3,  justify="right")
+    t.add_column("球队", width=22)
+    t.add_column("场",   width=4,  justify="right")
+    t.add_column("胜",   width=3,  justify="right", style="green")
+    t.add_column("平",   width=3,  justify="right", style="yellow")
+    t.add_column("负",   width=3,  justify="right", style="red")
+    t.add_column("进/失", width=7, justify="right")
+    t.add_column("净胜", width=5,  justify="right")
+    t.add_column("积分", width=5,  justify="right", style="bold cyan")
+    t.add_column("近5场", width=7)
+
+    for row in data["table"]:
+        gd = row["gd"]
+        gd_str = f"+{gd}" if gd > 0 else str(gd)
+        form_colored = ""
+        for c in (row.get("form") or ""):
+            if c == "W":
+                form_colored += "[green]W[/green]"
+            elif c == "L":
+                form_colored += "[red]L[/red]"
+            elif c == "D":
+                form_colored += "[yellow]D[/yellow]"
+            else:
+                form_colored += c
+        t.add_row(
+            str(row["pos"]),
+            row["team"],
+            str(row["played"]),
+            str(row["w"]),
+            str(row["d"]),
+            str(row["l"]),
+            f"{row['gf']}/{row['ga']}",
+            gd_str,
+            str(row["pts"]),
+            form_colored,
+        )
+
+    console.print(t)
+
+
+def _football_fixtures(league: str, days: int = 7) -> None:
+    from rich.table import Table
+    from rich import box as rich_box
+    try:
+        from football_data_client import get_fixtures, LEAGUE_NAMES, _resolve_league
+    except ImportError:
+        console.print("[red]football_data_client.py 未找到[/red]")
+        return
+
+    comp = _resolve_league(league)
+    league_label = LEAGUE_NAMES.get(comp, comp)
+    console.print(f"[dim]获取 {league_label} 未来 {days} 天赛程…[/dim]")
+
+    matches = get_fixtures(league, days)
+    if matches is None:
+        console.print("[yellow]无法获取数据。请检查 FOOTBALL_DATA_API_KEY 设置。[/yellow]")
+        return
+    if not matches:
+        console.print(f"[dim]未来 {days} 天内暂无赛事[/dim]")
+        return
+
+    t = Table(
+        title=f"[bold]{league_label}[/bold]  未来 {days} 天赛程",
+        box=rich_box.SIMPLE,
+        show_header=True,
+        header_style="bold",
+        padding=(0, 1),
+    )
+    t.add_column("日期(UTC)", width=11)
+    t.add_column("主队",      width=22)
+    t.add_column("",          width=3,  justify="center")
+    t.add_column("客队",      width=22)
+    t.add_column("轮次",      width=5,  justify="right")
+
+    for m in matches:
+        t.add_row(
+            m["date"],
+            m["home"],
+            "vs",
+            m["away"],
+            str(m["matchday"] or m.get("stage", "")),
+        )
+
+    console.print(t)
+
+
+def _football_team(team: str, league: str = "pl") -> None:
+    from rich.table import Table
+    from rich import box as rich_box
+    from rich.panel import Panel
+    try:
+        from football_data_client import get_team_stats
+    except ImportError:
+        console.print("[red]football_data_client.py 未找到[/red]")
+        return
+
+    console.print(f"[dim]获取 {team} 近期数据 ({league.upper()})…[/dim]")
+    stats = get_team_stats(league, team)
+    if not stats:
+        console.print("[yellow]无法获取球队数据。请检查球队名称和联赛代码。[/yellow]")
+        return
+
+    form_colored = ""
+    for c in stats["form"]:
+        if c == "W":   form_colored += "[bold green]W[/bold green]"
+        elif c == "L": form_colored += "[bold red]L[/bold red]"
+        elif c == "D": form_colored += "[bold yellow]D[/bold yellow]"
+
+    summary = (
+        f"[bold]{stats['team']}[/bold]  |  近 {stats['last_n']} 场\n\n"
+        f"  战绩:    {stats['w']}胜  {stats['d']}平  {stats['l']}负\n"
+        f"  进球:    {stats['gf']}球  (场均 {stats['avg_gf']})\n"
+        f"  失球:    {stats['ga']}球  (场均 {stats['avg_ga']})\n"
+        f"  主场进球: 场均 {stats['home_avg_gf']}\n"
+        f"  客场进球: 场均 {stats['away_avg_gf']}\n"
+        f"  近5场:   {form_colored}"
+    )
+    console.print(Panel(summary, title="[bold green]⚽ 球队状态[/bold green]", border_style="green"))
+
+    t = Table(box=rich_box.SIMPLE, show_header=True, padding=(0, 1))
+    t.add_column("日期",     width=10)
+    t.add_column("主队",     width=20)
+    t.add_column("比分",     width=7, justify="center", style="bold")
+    t.add_column("客队",     width=20)
+    t.add_column("",         width=3)
+
+    for r in stats["recent"]:
+        result_style = {"W": "green", "D": "yellow", "L": "red"}.get(r["result"], "dim")
+        t.add_row(
+            r["date"],
+            r["home"],
+            r["score"],
+            r["away"],
+            f"[{result_style}]{r['result']}[/{result_style}]",
+        )
+    console.print(t)
+
+
+def _football_h2h(t1: str, t2: str, league: str = "pl") -> None:
+    from rich.table import Table
+    from rich import box as rich_box
+    from rich.panel import Panel
+    try:
+        from football_data_client import get_head_to_head
+    except ImportError:
+        console.print("[red]football_data_client.py 未找到[/red]")
+        return
+
+    console.print(f"[dim]获取 {t1} vs {t2} 历史对决 ({league.upper()})…[/dim]")
+    data = get_head_to_head(t1, t2, league)
+    if not data:
+        console.print("[yellow]未找到历史对决记录。[/yellow]")
+        return
+
+    summary = (
+        f"[bold]{data['team1']}[/bold] vs [bold]{data['team2']}[/bold]  |  共 {data['total']} 场\n\n"
+        f"  {data['team1']} 胜: [green]{data['team1_wins']}[/green]\n"
+        f"  平局:         [yellow]{data['draws']}[/yellow]\n"
+        f"  {data['team2']} 胜: [red]{data['team2_wins']}[/red]"
+    )
+    console.print(Panel(summary, title="[bold]⚽ 历史交锋[/bold]", border_style="dim"))
+
+    t = Table(box=rich_box.SIMPLE, show_header=True, padding=(0, 1))
+    t.add_column("日期", width=10)
+    t.add_column("主队", width=22)
+    t.add_column("比分", width=7, justify="center", style="bold cyan")
+    t.add_column("客队", width=22)
+
+    for m in data["matches"]:
+        t.add_row(m["date"], m["home"], m["score"], m["away"])
+    console.print(t)
+
+

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

aria_code/apps/cli/google_login.py

@@ -0,0 +1,196 @@
+"""Google sign-in for the CLI, following RFC 8252's native-app flow.
+
+The desktop app receives its OAuth callback through the arthera:// URL scheme it
+registers with the OS. A CLI cannot own a scheme, so it does what RFC 8252
+prescribes instead: bind an ephemeral port on loopback, hand that port to the
+gateway, and let the browser deliver the callback there.
+
+Three properties are worth keeping in mind when editing this:
+
+* Only a port number is sent to the gateway, never a redirect URL. The callback
+  builds the loopback address itself, so a caller cannot point the credential
+  delivery anywhere else.
+* What arrives on loopback is a single-use handoff code, not a token. The code is
+  redeemed over POST, so the browser history never holds a credential.
+* The gateway returns a *Google* ID token. The Arthera API authenticates with
+  *Firebase* ID tokens, so the credential is exchanged with Identity Toolkit
+  before it is stored — the same exchange the desktop app performs through the
+  Firebase SDK.
+"""
+
+from __future__ import annotations
+
+import http.server
+import json
+import secrets
+import socket
+import threading
+import urllib.parse
+import urllib.request
+import webbrowser
+from typing import Any, Dict, Optional
+
+# The Firebase Web API key is public by design — it identifies the project and
+# authorises nothing on its own. It is the same value the web and desktop
+# clients ship in their bundles.
+FIREBASE_WEB_API_KEY = "AIzaSyC9iYiroXgxTu2ANUPIjeGbITVzWEUjXAI"
+IDENTITY_TOOLKIT_SIGN_IN_WITH_IDP = (
+    "https://identitytoolkit.googleapis.com/v1/accounts:signInWithIdp"
+)
+
+_LOGIN_TIMEOUT_SECONDS = 300
+
+
+class _CallbackResult:
+    def __init__(self) -> None:
+        self.params: Dict[str, str] = {}
+        self.received = threading.Event()
+
+
+def _make_handler(result: _CallbackResult, expected_path: str):
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802 - name fixed by BaseHTTPRequestHandler
+            parsed = urllib.parse.urlparse(self.path)
+            if parsed.path != expected_path:
+                self.send_response(404)
+                self.end_headers()
+                return
+
+            result.params = {
+                k: v[0] for k, v in urllib.parse.parse_qs(parsed.query).items()
+            }
+            ok = "handoff_code" in result.params
+            body = (
+                "<html><body style='font-family:system-ui;padding:3rem'>"
+                f"<h2>{'Signed in.' if ok else 'Sign-in failed.'}</h2>"
+                "<p>You can close this tab and return to the terminal.</p>"
+                "</body></html>"
+            ).encode("utf-8")
+
+            self.send_response(200 if ok else 400)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            result.received.set()
+
+        def log_message(self, *args):  # keep the terminal clean
+            return
+
+    return Handler
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def _post_json(url: str, payload: Dict[str, Any], timeout: int = 20) -> Dict[str, Any]:
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def exchange_google_token_for_firebase(google_id_token: str) -> Dict[str, Any]:
+    """Trade a verified Google ID token for a Firebase session.
+
+    requestUri is required by the endpoint but only has to be a well-formed URL
+    the project would accept; nothing is fetched from it.
+    """
+    body = {
+        "postBody": urllib.parse.urlencode(
+            {"id_token": google_id_token, "providerId": "google.com"}
+        ),
+        "requestUri": "http://127.0.0.1",
+        "returnIdpCredential": True,
+        "returnSecureToken": True,
+    }
+    return _post_json(
+        f"{IDENTITY_TOOLKIT_SIGN_IN_WITH_IDP}?key={FIREBASE_WEB_API_KEY}", body
+    )
+
+
+def run_google_login(api_url: str, region: str = "GLOBAL") -> Dict[str, Any]:
+    """Drive the whole flow and return the stored-credential fields.
+
+    Raises RuntimeError with a message suitable for display on any failure.
+    """
+    api_url = api_url.rstrip("/")
+    port = _free_port()
+    callback_path = "/callback"
+    result = _CallbackResult()
+
+    server = http.server.HTTPServer(
+        ("127.0.0.1", port), _make_handler(result, callback_path)
+    )
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+
+    try:
+        login_url = (
+            f"{api_url}/api/v2/auth/google/login?"
+            + urllib.parse.urlencode(
+                {"platform": "cli", "region": region, "port": port}
+            )
+        )
+        opened = webbrowser.open(login_url)
+        if not opened:
+            raise RuntimeError(
+                "Could not open a browser. Visit this URL manually:\n  " + login_url
+            )
+
+        if not result.received.wait(timeout=_LOGIN_TIMEOUT_SECONDS):
+            raise RuntimeError(
+                f"Timed out after {_LOGIN_TIMEOUT_SECONDS}s waiting for the browser."
+            )
+    finally:
+        server.shutdown()
+        server.server_close()
+
+    if "message" in result.params and "handoff_code" not in result.params:
+        raise RuntimeError(result.params["message"])
+
+    handoff_code = result.params.get("handoff_code")
+    if not handoff_code:
+        raise RuntimeError("The sign-in callback did not carry a handoff code.")
+
+    try:
+        exchanged = _post_json(
+            f"{api_url}/api/v2/auth/handoff/exchange", {"code": handoff_code}
+        )
+    except Exception as exc:
+        raise RuntimeError(f"Could not redeem the sign-in handoff: {exc}") from exc
+
+    payload = exchanged.get("data") or {}
+    google_id_token = payload.get("token")
+    if not google_id_token:
+        raise RuntimeError("The sign-in handoff did not contain a credential.")
+
+    try:
+        session = exchange_google_token_for_firebase(google_id_token)
+    except Exception as exc:
+        raise RuntimeError(f"Firebase rejected the Google credential: {exc}") from exc
+
+    id_token = session.get("idToken")
+    if not id_token:
+        raise RuntimeError("Firebase did not return a session token.")
+
+    return {
+        "auth_token": id_token,
+        "refresh_token": session.get("refreshToken"),
+        # expiresIn is seconds-as-string; the caller decides how to persist it.
+        "expires_in": session.get("expiresIn"),
+        "user_id": session.get("localId") or payload.get("uid"),
+        "email": session.get("email") or payload.get("email"),
+        "display_name": session.get("displayName") or payload.get("display_name"),
+        "provider": "google.com",
+    }
+
+
+__all__ = ["run_google_login", "exchange_google_token_for_firebase"]

aria_code/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",
+]