trading-cli 0.3.0__py3-none-any.whl

fastbooks_cli/commands/markets.py

@@ -0,0 +1,270 @@
+"""Markets command group — orderbooks, tickers, OHLCV, symbols, options."""
+
+from __future__ import annotations
+
+import csv
+import json
+
+import click
+
+from ..client import FastBooksClient
+from ..output import emit, emit_error, format_table
+
+# Safety bounds for --all auto-pagination so a bad backend can't loop forever.
+_ALL_PAGE_SIZE = 1000
+_ALL_MAX_PAGES = 500
+_ALL_MAX_ROWS = 500_000
+
+SUPPORTED_EXCHANGES = [
+    "binance", "bybit", "okx", "kraken", "coinbase", "kucoin",
+    "hyperliquid", "deribit", "polymarket", "limitless",
+]
+
+TIMEFRAMES = ["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w"]
+
+REGIONS = ["us", "ca", "uk", "au", "eu", "jp", "asia"]
+
+
+@click.group()
+def markets():
+    """Market data: orderbooks, tickers, OHLCV, symbols, options."""
+    pass
+
+
+# ── orderbook ────────────────────────────────────────────────────────────
+
+@markets.command()
+@click.argument("exchange", type=click.Choice(SUPPORTED_EXCHANGES, case_sensitive=False))
+@click.argument("symbol")
+@click.pass_context
+def orderbook(ctx, exchange: str, symbol: str):
+    """Fetch orderbook for SYMBOL on EXCHANGE.
+
+    Examples:
+        fastbooks markets orderbook binance BTC/USDT
+        fastbooks markets orderbook hyperliquid ETH/USDC
+        fastbooks markets orderbook polymarket "Will Trump win?"
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.orderbook(exchange, symbol)
+        emit(ctx, data, lambda d: _format_orderbook(d))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _format_orderbook(data: dict) -> str:
+    lines = []
+    ob = data if "exchange" in data else data.get("data", data)
+    lines.append(f"  {ob.get('exchange', '?')} | {ob.get('symbol', '?')}")
+    lines.append(f"  Mid: {ob.get('midPrice', '?')}  Spread: {ob.get('spreadPercent', '?')}%")
+    lines.append("")
+
+    asks = ob.get("asks", [])[:5]
+    bids = ob.get("bids", [])[:5]
+    lines.append("  ASKS (top 5):")
+    for price, size in reversed(asks):
+        lines.append(f"    {price:>12}  {size:>12}")
+    lines.append("  ─────────────────────────")
+    lines.append("  BIDS (top 5):")
+    for price, size in bids:
+        lines.append(f"    {price:>12}  {size:>12}")
+    return "\n".join(lines)
+
+
+# ── aggregated orderbooks ────────────────────────────────────────────────
+
+@markets.command()
+@click.option("--category", type=click.Choice(["all", "spot", "perpetuals"]), default="all")
+@click.pass_context
+def orderbooks(ctx, category: str):
+    """Fetch aggregated orderbooks across all exchanges.
+
+    Categories: all, spot, perpetuals.
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.orderbooks_aggregated(category)
+        emit(ctx, data)
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ── tickers ──────────────────────────────────────────────────────────────
+
+@markets.command()
+@click.option("--category", type=str, default=None, help="Filter: crypto, stocks, forex, dex.")
+@click.option("--exchange", type=str, default=None, help="Filter by exchange name.")
+@click.option("--search", type=str, default=None, help="Search by symbol or name.")
+@click.option("--page", type=int, default=1, help="Page number.")
+@click.option("--limit", type=int, default=50, help="Results per page.")
+@click.option("--all", "fetch_all", is_flag=True, help="Fetch the FULL universe (auto-paginate). Ignores --page.")
+@click.option("--export", "export_path", type=click.Path(dir_okay=False, writable=True), default=None,
+              help="Write results to a file (.json or .csv inferred from extension).")
+@click.pass_context
+def tickers(ctx, category, exchange, search, page, limit, fetch_all, export_path):
+    """List tickers across all supported markets.
+
+    Examples:
+        fastbooks markets tickers --category crypto --limit 20
+        fastbooks markets tickers --search AAPL
+        fastbooks markets tickers --all                       # entire universe
+        fastbooks markets tickers --all --category stocks --export stocks.csv
+        fastbooks --json markets tickers --all > universe.json
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        if fetch_all:
+            data = _fetch_all_tickers(client, category=category, exchange=exchange, search=search)
+        else:
+            data = client.tickers(page=page, limit=limit, category=category, exchange=exchange, search=search)
+
+        if export_path:
+            items = _extract_tickers(data)
+            _write_export(items, export_path)
+            emit(ctx, {"exported": len(items), "path": export_path},
+                 lambda d: f"  Exported {d['exported']} tickers to {d['path']}")
+            return
+
+        emit(ctx, data, lambda d: _format_tickers(d))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _extract_tickers(data) -> list:
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        items = data.get("tickers", data.get("data", []))
+        return items if isinstance(items, list) else []
+    return []
+
+
+def _fetch_all_tickers(client: FastBooksClient, category=None, exchange=None, search=None) -> dict:
+    """Auto-paginate /tickers/all into a single combined result (bounded)."""
+    all_items: list = []
+    page = 1
+    while page <= _ALL_MAX_PAGES and len(all_items) < _ALL_MAX_ROWS:
+        resp = client.tickers(page=page, limit=_ALL_PAGE_SIZE, category=category, exchange=exchange, search=search)
+        batch = _extract_tickers(resp)
+        if not batch:
+            break
+        all_items.extend(batch)
+        if len(batch) < _ALL_PAGE_SIZE:
+            break  # last page
+        page += 1
+    return {"tickers": all_items, "total": len(all_items), "pages": page}
+
+
+_EXPORT_COLUMNS = ["symbol", "name", "exchange", "category", "price", "change24h", "volume24h"]
+
+
+def _write_export(items: list, path: str) -> None:
+    if path.lower().endswith(".csv"):
+        with open(path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=_EXPORT_COLUMNS, extrasaction="ignore")
+            writer.writeheader()
+            for it in items:
+                if isinstance(it, dict):
+                    writer.writerow({k: it.get(k, "") for k in _EXPORT_COLUMNS})
+    else:
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(items, f, indent=2, default=str)
+
+
+def _format_tickers(data: dict) -> str:
+    items = _extract_tickers(data)
+    if not isinstance(items, list):
+        return str(data)
+    total = data.get("total", len(items)) if isinstance(data, dict) else len(items)
+    table = format_table(
+        items[:50],
+        ["symbol", "exchange", "price", "change24h", "volume24h"],
+        ["Symbol", "Exchange", "Price", "24h Change", "24h Volume"],
+    )
+    if len(items) > 50:
+        table += f"\n  … showing 50 of {total} (use --export to save all, or --json for full output)"
+    return table
+
+
+# ── OHLCV ────────────────────────────────────────────────────────────────
+
+@markets.command()
+@click.argument("exchange", type=str)
+@click.argument("symbol", type=str)
+@click.option("--timeframe", "-t", type=click.Choice(TIMEFRAMES), default="1h", help="Candle timeframe.")
+@click.option("--limit", "-n", type=int, default=50, help="Number of candles.")
+@click.pass_context
+def ohlcv(ctx, exchange: str, symbol: str, timeframe: str, limit: int):
+    """Fetch OHLCV candle data.
+
+    Examples:
+        fastbooks markets ohlcv binance BTC/USDT --timeframe 1d --limit 30
+        fastbooks markets ohlcv alpaca AAPL -t 1h -n 100
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.ohlcv(exchange, symbol, timeframe, limit)
+        emit(ctx, data, lambda d: _format_ohlcv(d))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _format_ohlcv(data: dict) -> str:
+    bars = data if isinstance(data, list) else data.get("data", data.get("bars", []))
+    if not isinstance(bars, list) or not bars:
+        return str(data)
+    return format_table(
+        bars[:20],
+        ["timestamp", "open", "high", "low", "close", "volume"],
+        ["Time", "Open", "High", "Low", "Close", "Volume"],
+    )
+
+
+# ── symbols ──────────────────────────────────────────────────────────────
+
+@markets.command()
+@click.option("--region", "-r", type=click.Choice(REGIONS), default="us", help="Market region.")
+@click.option("--sector", "-s", type=str, default=None, help="Filter by sector.")
+@click.option("--limit", "-n", type=int, default=100, help="Max symbols.")
+@click.pass_context
+def symbols(ctx, region: str, sector: str | None, limit: int):
+    """List symbols from the universe.
+
+    Regions: us, ca, uk, au, eu, jp, asia.
+
+    Examples:
+        fastbooks markets symbols --region us --sector Technology --limit 50
+        fastbooks markets symbols -r ca -n 200
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.symbols_universe(region, sector, limit)
+        emit(ctx, data)
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ── options chain ────────────────────────────────────────────────────────
+
+@markets.command()
+@click.argument("underlying")
+@click.pass_context
+def options(ctx, underlying: str):
+    """Fetch options chain for UNDERLYING (Deribit).
+
+    Example:
+        fastbooks markets options BTC
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.options_chain(underlying)
+        emit(ctx, data)
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)

fastbooks_cli/commands/mcp_cmd.py

@@ -0,0 +1,27 @@
+"""`mcp` — launch the FastBooks MCP server (stdio) for AI agents."""
+
+from __future__ import annotations
+
+import click
+
+from ..output import emit_error
+
+
+@click.command("mcp")
+@click.pass_context
+def mcp_cmd(ctx: click.Context):
+    """Start the FastBooks MCP server over stdio (for Claude / MCP-compatible agents).
+
+    Exposes STANDALONE ccxt tools (100+ exchanges, keyless market data + direct trading)
+    plus FastBooks PLATFORM tools (aggregated multi-asset data, the 15-venue execution
+    layer, managed bots) when a backend is reachable. Point your agent at this command:
+
+        {"command": "fastbooks", "args": ["mcp"]}      # or the `fastbooks-mcp` script
+    """
+    try:
+        from ..mcp_server import build_server
+    except RuntimeError as e:  # MCP SDK missing
+        emit_error(ctx, str(e))
+        ctx.exit(2)
+        return
+    build_server().run()

fastbooks_cli/commands/onchain.py

@@ -0,0 +1,123 @@
+"""`onchain` — FastBots on-chain engine (Solana/EVM: Jupiter / Pump.fun / Hyperliquid).
+
+Proxies the isolated solana-trading-bots engine via the backend's `/api/onchain/*` route.
+That proxy is auth + email-gated, so these commands need `--token` / FASTBOOKS_API_TOKEN
+(a JWT whose email is on the engine's allowlist).
+"""
+
+from __future__ import annotations
+
+import click
+
+from ..client import FastBooksClient
+from ..output import emit, emit_error
+
+
+@click.group()
+def onchain():
+    """FastBots on-chain engine — status, strategies, positions, and live bot control.
+
+    Real-money on-chain execution on Solana/EVM. Requires --token (JWT on the engine allowlist).
+    """
+
+
+@onchain.command("status")
+@click.pass_context
+def status_cmd(ctx: click.Context):
+    """Live runner status — which on-chain bots are running."""
+    client: FastBooksClient = ctx.obj
+    try:
+        emit(ctx, client.onchain_live_status())
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@onchain.command("stats")
+@click.option("--by-bot", is_flag=True, help="Per-bot realized PnL breakdown.")
+@click.pass_context
+def stats_cmd(ctx: click.Context, by_bot: bool):
+    """Realized PnL / win-rate stats (global or per bot)."""
+    client: FastBooksClient = ctx.obj
+    try:
+        emit(ctx, client.onchain_stats(by_bot=by_bot))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@onchain.command("strategies")
+@click.pass_context
+def strategies_cmd(ctx: click.Context):
+    """List deployable on-chain strategies + their params."""
+    client: FastBooksClient = ctx.obj
+    try:
+        emit(ctx, client.onchain_strategies())
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@onchain.command("positions")
+@click.option("--status", default=None, help="open | closed | failed")
+@click.pass_context
+def positions_cmd(ctx: click.Context, status: str | None):
+    """Open/closed on-chain positions."""
+    client: FastBooksClient = ctx.obj
+    try:
+        emit(ctx, client.onchain_positions(status))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@onchain.command("trades")
+@click.option("--limit", "-n", default=40, type=int)
+@click.pass_context
+def trades_cmd(ctx: click.Context, limit: int):
+    """Recent on-chain trades."""
+    client: FastBooksClient = ctx.obj
+    try:
+        emit(ctx, client.onchain_trades(limit))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@onchain.command("start")
+@click.argument("strategy_id")
+@click.option("--alloc", type=float, default=None, help="Max SOL allocation for this bot (maxAllocationSol).")
+@click.option("--slippage-bps", type=int, default=None, help="Real swap slippage tolerance (bps).")
+@click.option("--max-safety-risk", type=int, default=None, help="Block entries at/above this risk score (e.g. 40 to allow caution).")
+@click.option("--yes", is_flag=True, help="Skip the real-funds confirmation.")
+@click.pass_context
+def start_cmd(ctx, strategy_id, alloc, slippage_bps, max_safety_risk, yes):
+    """Start a live on-chain bot — REAL FUNDS. e.g. onchain start high_winrate_v2 --alloc 0.5 --max-safety-risk 40"""
+    client: FastBooksClient = ctx.obj
+    if not yes and not ctx.find_root().params.get("json_output"):
+        click.confirm(f"Start LIVE on-chain bot '{strategy_id}' with REAL funds?", abort=True)
+    opts: dict = {}
+    if alloc is not None:
+        opts["maxAllocationSol"] = alloc
+    if slippage_bps is not None:
+        opts["realSlippageBps"] = slippage_bps
+    if max_safety_risk is not None:
+        opts["maxSafetyRisk"] = max_safety_risk
+    try:
+        emit(ctx, client.onchain_live_start(strategy_id, opts))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@onchain.command("stop")
+@click.argument("strategy_id")
+@click.pass_context
+def stop_cmd(ctx: click.Context, strategy_id: str):
+    """Stop a live on-chain bot."""
+    client: FastBooksClient = ctx.obj
+    try:
+        emit(ctx, client.onchain_live_stop(strategy_id))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)