probable-trader 1.0.0

package/scripts/prob.py

@@ -0,0 +1,474 @@
+#!/usr/bin/env python3
+"""Probable Markets CLI — Agent-native trading skill for BSC prediction markets.
+
+Usage: python3 scripts/prob.py <command> [options]
+"""
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+# Ensure lib is importable
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from lib.config import ProbableConfig, load_config, init_config_dir
+from lib.safety import ActionResult, require_confirm, output_result
+from lib.db import ProbableDB
+from lib.client_wrapper import ProbableClient
+
+
+def get_client(args) -> ProbableClient:
+    cfg = load_config()
+    db = ProbableDB(cfg.db_path)
+    return ProbableClient(cfg=cfg, db=db)
+
+
+# ── Config commands ──────────────────────────────────────────────
+
+def cmd_config_show(args):
+    cfg = load_config()
+    result = ActionResult(success=True, action="config.show", data=cfg.to_dict(mask_secrets=True))
+    output_result(result, args.json)
+
+
+def cmd_config_init(args):
+    path = init_config_dir()
+    result = ActionResult(success=True, action="config.init", data={"path": str(path)})
+    output_result(result, args.json)
+
+
+# ── Doctor ───────────────────────────────────────────────────────
+
+def cmd_doctor(args):
+    client = get_client(args)
+    result = client.doctor()
+    output_result(result, args.json)
+
+
+# ── Setup (onboard) ─────────────────────────────────────────────
+
+def cmd_setup(args):
+    client = get_client(args)
+
+    # Doctor first
+    doc = client.doctor()
+    if not doc.success:
+        output_result(doc, args.json)
+        return
+
+    blocked = require_confirm("setup", {"action": "enable_trading (approve tokens)"}, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+
+    result = client.enable_trading()
+    output_result(result, args.json)
+
+
+# ── Onboard ──────────────────────────────────────────────────────
+
+def cmd_onboard(args):
+    cfg = load_config()
+    details = {"action": "Generate API key via L1 auth (EIP-712 signing)"}
+    blocked = require_confirm("onboard", details, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+
+    from lib.onboard import run_onboard
+    result = run_onboard(cfg)
+    output_result(result, args.json)
+
+
+# ── Market commands ──────────────────────────────────────────────
+
+def cmd_market_list(args):
+    client = get_client(args)
+    result = client.get_markets(
+        topic_type=args.type,
+        page=args.page,
+        limit=args.limit,
+        status=args.status,
+        sort_by=args.sort_by,
+    )
+    output_result(result, args.json)
+
+
+def cmd_market_get(args):
+    client = get_client(args)
+    result = client.get_market(int(args.market_id))
+    output_result(result, args.json)
+
+
+def cmd_market_search(args):
+    client = get_client(args)
+    # Search is implemented as filtered list — get all and filter client-side
+    result = client.get_markets(page=1, limit=20)
+    if result.success and result.data:
+        query = args.query.lower()
+        items = result.data if isinstance(result.data, list) else result.data.get("items", result.data.get("data", []))
+        if isinstance(items, list):
+            filtered = [m for m in items if query in json.dumps(m, default=str).lower()]
+            result = ActionResult(success=True, action="market.search",
+                                  data={"query": args.query, "results": filtered, "count": len(filtered)})
+    output_result(result, args.json)
+
+
+# ── Book / Price / History / Fee ─────────────────────────────────
+
+def cmd_book(args):
+    client = get_client(args)
+    result = client.get_orderbook(args.token_id)
+    output_result(result, args.json)
+
+
+def cmd_price(args):
+    client = get_client(args)
+    result = client.get_latest_price(args.token_id)
+    output_result(result, args.json)
+
+
+def cmd_history(args):
+    client = get_client(args)
+    result = client.get_price_history(args.token_id, interval=args.interval)
+    output_result(result, args.json)
+
+
+def cmd_fee_rates(args):
+    client = get_client(args)
+    result = client.get_fee_rates(args.token_id)
+    output_result(result, args.json)
+
+
+# ── Order commands ───────────────────────────────────────────────
+
+def cmd_order_place(args):
+    client = get_client(args)
+    details = {
+        "market_id": args.market_id, "token_id": args.token_id,
+        "side": args.side, "price": args.price, "amount": args.amount,
+        "order_type": args.type or "limit",
+    }
+    blocked = require_confirm("order.place", details, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+    result = client.place_order(
+        market_id=int(args.market_id), token_id=args.token_id,
+        side=args.side, price=args.price, amount=args.amount,
+        order_type=args.type or "limit",
+    )
+    output_result(result, args.json)
+
+
+def cmd_order_get(args):
+    client = get_client(args)
+    result = client.get_order_by_id(args.order_id)
+    output_result(result, args.json)
+
+
+def cmd_order_list(args):
+    client = get_client(args)
+    result = client.get_my_orders(
+        market_id=int(args.market_id) if args.market_id else 0,
+        status=args.status or "",
+        limit=10, page=1,
+    )
+    output_result(result, args.json)
+
+
+def cmd_order_cancel(args):
+    client = get_client(args)
+    blocked = require_confirm("order.cancel", {"order_id": args.order_id}, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+    result = client.cancel_order(args.order_id)
+    output_result(result, args.json)
+
+
+def cmd_order_cancel_all(args):
+    client = get_client(args)
+    details = {"market_id": args.market_id}
+    blocked = require_confirm("order.cancel_all", details, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+    mid = int(args.market_id) if args.market_id else None
+    result = client.cancel_all_orders(market_id=mid)
+    output_result(result, args.json)
+
+
+# ── Positions / Trades / Balance ─────────────────────────────────
+
+def cmd_positions(args):
+    client = get_client(args)
+    mid = int(args.market_id) if args.market_id else 0
+    result = client.get_my_positions(market_id=mid)
+    output_result(result, args.json)
+
+
+def cmd_trades(args):
+    client = get_client(args)
+    mid = int(args.market_id) if args.market_id else None
+    result = client.get_my_trades(market_id=mid, page=args.page)
+    output_result(result, args.json)
+
+
+def cmd_balance(args):
+    client = get_client(args)
+    result = client.get_my_balances()
+    output_result(result, args.json)
+
+
+# ── Split / Merge / Redeem ───────────────────────────────────────
+
+def cmd_split(args):
+    client = get_client(args)
+    details = {"market_id": args.market_id, "amount": args.amount}
+    blocked = require_confirm("split", details, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+    result = client.split(int(args.market_id), int(args.amount))
+    output_result(result, args.json)
+
+
+def cmd_merge(args):
+    client = get_client(args)
+    details = {"market_id": args.market_id, "amount": args.amount}
+    blocked = require_confirm("merge", details, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+    result = client.merge(int(args.market_id), int(args.amount))
+    output_result(result, args.json)
+
+
+def cmd_redeem(args):
+    client = get_client(args)
+    details = {"market_id": args.market_id}
+    blocked = require_confirm("redeem", details, args.confirm, args.dry_run)
+    if blocked:
+        output_result(blocked, args.json)
+        return
+    result = client.redeem(int(args.market_id))
+    output_result(result, args.json)
+
+
+# ── WebSocket commands ───────────────────────────────────────────
+
+def cmd_ws_book(args):
+    from lib.ws_client import subscribe_book
+    asyncio.run(subscribe_book(args.token_id, duration=args.duration, json_mode=args.json))
+
+
+def cmd_ws_user(args):
+    cfg = load_config()
+    from lib.ws_client import subscribe_user
+    asyncio.run(subscribe_user(cfg, duration=args.duration, json_mode=args.json))
+
+
+# ── Report command ───────────────────────────────────────────────
+
+def cmd_report_daily(args):
+    cfg = load_config()
+    db = ProbableDB(cfg.db_path)
+    from lib.report import generate_daily_report
+    result = generate_daily_report(db, fmt=args.format)
+    if args.output:
+        Path(args.output).write_text(result.to_json() if args.json else json.dumps(result.data, indent=2, default=str))
+        print(f"Report written to {args.output}")
+    else:
+        output_result(result, args.json)
+
+
+# ── Argument parser ──────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    # Shared parent with global flags — allows --json/--confirm/--dry-run anywhere
+    parent = argparse.ArgumentParser(add_help=False)
+    parent.add_argument("--json", action="store_true", help="JSON-only output")
+    parent.add_argument("--confirm", action="store_true", help="Confirm destructive actions")
+    parent.add_argument("--dry-run", action="store_true", help="Preview without executing")
+
+    p = argparse.ArgumentParser(prog="prob.py", description="Probable Markets CLI", parents=[parent])
+
+    sub = p.add_subparsers(dest="command", help="Available commands")
+
+    # config
+    cfg_p = sub.add_parser("config", help="Configuration", parents=[parent])
+    cfg_sub = cfg_p.add_subparsers(dest="config_cmd")
+    cfg_sub.add_parser("show", help="Show current config", parents=[parent])
+    cfg_sub.add_parser("init", help="Create .probable/ directory", parents=[parent])
+
+    # doctor / onboard / setup
+    sub.add_parser("doctor", help="Health check", parents=[parent])
+    sub.add_parser("onboard", help="Generate API key (L1 auth, only needs private key)", parents=[parent])
+    sub.add_parser("setup", help="Enable trading approvals (on-chain)", parents=[parent])
+
+    # market
+    mkt_p = sub.add_parser("market", help="Market discovery", parents=[parent])
+    mkt_sub = mkt_p.add_subparsers(dest="market_cmd")
+
+    mkt_list = mkt_sub.add_parser("list", help="List markets", parents=[parent])
+    mkt_list.add_argument("--type", choices=["binary", "categorical", "all"], default=None)
+    mkt_list.add_argument("--status", choices=["activated", "resolved"], default=None)
+    mkt_list.add_argument("--sort-by", dest="sort_by",
+                          choices=["time", "volume", "volume_24h", "volume_7d", "cutoff"], default=None)
+    mkt_list.add_argument("--page", type=int, default=1)
+    mkt_list.add_argument("--limit", type=int, default=20)
+
+    mkt_get = mkt_sub.add_parser("get", help="Get market details", parents=[parent])
+    mkt_get.add_argument("market_id", help="Market ID")
+
+    mkt_search = mkt_sub.add_parser("search", help="Search markets", parents=[parent])
+    mkt_search.add_argument("query", help="Search query")
+
+    # book
+    book_p = sub.add_parser("book", help="Orderbook snapshot", parents=[parent])
+    book_p.add_argument("token_id", help="Token ID")
+
+    # price
+    price_p = sub.add_parser("price", help="Latest price", parents=[parent])
+    price_p.add_argument("token_id", help="Token ID")
+
+    # history
+    hist_p = sub.add_parser("history", help="Price history", parents=[parent])
+    hist_p.add_argument("token_id", help="Token ID")
+    hist_p.add_argument("--interval", choices=["1m", "1h", "1d", "1w", "max"], default="1h")
+
+    # fee-rates
+    fee_p = sub.add_parser("fee-rates", help="Fee rates from chain", parents=[parent])
+    fee_p.add_argument("token_id", help="Token ID")
+
+    # order
+    ord_p = sub.add_parser("order", help="Order management", parents=[parent])
+    ord_sub = ord_p.add_subparsers(dest="order_cmd")
+
+    ord_place = ord_sub.add_parser("place", help="Place order", parents=[parent])
+    ord_place.add_argument("--market-id", required=True, dest="market_id")
+    ord_place.add_argument("--token-id", required=True, dest="token_id")
+    ord_place.add_argument("--side", required=True, choices=["BUY", "SELL"])
+    ord_place.add_argument("--price", required=True)
+    ord_place.add_argument("--amount", required=True)
+    ord_place.add_argument("--type", choices=["limit", "market"], default="limit")
+
+    ord_get = ord_sub.add_parser("get", help="Get order details", parents=[parent])
+    ord_get.add_argument("order_id", help="Order ID")
+
+    ord_list = ord_sub.add_parser("list", help="List my orders", parents=[parent])
+    ord_list.add_argument("--market-id", dest="market_id", default=None)
+    ord_list.add_argument("--status", choices=["pending", "filled", "cancelled"], default=None)
+
+    ord_cancel = ord_sub.add_parser("cancel", help="Cancel order", parents=[parent])
+    ord_cancel.add_argument("order_id", help="Order ID")
+
+    ord_cancel_all = ord_sub.add_parser("cancel-all", help="Cancel all orders", parents=[parent])
+    ord_cancel_all.add_argument("--market-id", dest="market_id", default=None)
+
+    # positions / trades / balance
+    pos_p = sub.add_parser("positions", help="My positions", parents=[parent])
+    pos_p.add_argument("--market-id", dest="market_id", default=None)
+
+    trades_p = sub.add_parser("trades", help="My trades", parents=[parent])
+    trades_p.add_argument("--market-id", dest="market_id", default=None)
+    trades_p.add_argument("--page", type=int, default=1)
+
+    sub.add_parser("balance", help="My balances", parents=[parent])
+
+    # split / merge / redeem
+    split_p = sub.add_parser("split", help="Split collateral into outcome tokens", parents=[parent])
+    split_p.add_argument("--market-id", required=True, dest="market_id")
+    split_p.add_argument("--amount", required=True)
+
+    merge_p = sub.add_parser("merge", help="Merge outcome tokens into collateral", parents=[parent])
+    merge_p.add_argument("--market-id", required=True, dest="market_id")
+    merge_p.add_argument("--amount", required=True)
+
+    redeem_p = sub.add_parser("redeem", help="Redeem resolved market", parents=[parent])
+    redeem_p.add_argument("--market-id", required=True, dest="market_id")
+
+    # ws
+    ws_p = sub.add_parser("ws", help="WebSocket streams", parents=[parent])
+    ws_sub = ws_p.add_subparsers(dest="ws_cmd")
+
+    ws_book = ws_sub.add_parser("book", help="Stream orderbook updates", parents=[parent])
+    ws_book.add_argument("token_id", help="Token ID")
+    ws_book.add_argument("--duration", type=int, default=60, help="Duration in seconds")
+
+    ws_user = ws_sub.add_parser("user", help="Stream execution reports", parents=[parent])
+    ws_user.add_argument("--duration", type=int, default=60, help="Duration in seconds")
+
+    # report
+    rpt_p = sub.add_parser("report", help="Trading reports", parents=[parent])
+    rpt_sub = rpt_p.add_subparsers(dest="report_cmd")
+
+    rpt_daily = rpt_sub.add_parser("daily", help="Daily trading report", parents=[parent])
+    rpt_daily.add_argument("--format", choices=["markdown", "json", "both"], default="markdown")
+    rpt_daily.add_argument("--output", default=None, help="Output file path")
+
+    return p
+
+
+DISPATCH = {
+    ("config", "show"): cmd_config_show,
+    ("config", "init"): cmd_config_init,
+    ("doctor", None): cmd_doctor,
+    ("onboard", None): cmd_onboard,
+    ("setup", None): cmd_setup,
+    ("market", "list"): cmd_market_list,
+    ("market", "get"): cmd_market_get,
+    ("market", "search"): cmd_market_search,
+    ("book", None): cmd_book,
+    ("price", None): cmd_price,
+    ("history", None): cmd_history,
+    ("fee-rates", None): cmd_fee_rates,
+    ("order", "place"): cmd_order_place,
+    ("order", "get"): cmd_order_get,
+    ("order", "list"): cmd_order_list,
+    ("order", "cancel"): cmd_order_cancel,
+    ("order", "cancel-all"): cmd_order_cancel_all,
+    ("positions", None): cmd_positions,
+    ("trades", None): cmd_trades,
+    ("balance", None): cmd_balance,
+    ("split", None): cmd_split,
+    ("merge", None): cmd_merge,
+    ("redeem", None): cmd_redeem,
+    ("ws", "book"): cmd_ws_book,
+    ("ws", "user"): cmd_ws_user,
+    ("report", "daily"): cmd_report_daily,
+}
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # Determine sub-command
+    sub_cmd = None
+    for attr in ("config_cmd", "market_cmd", "order_cmd", "ws_cmd", "report_cmd"):
+        if hasattr(args, attr):
+            sub_cmd = getattr(args, attr)
+            break
+
+    key = (args.command, sub_cmd)
+    fn = DISPATCH.get(key)
+    if fn is None:
+        # Try command-only dispatch
+        fn = DISPATCH.get((args.command, None))
+    if fn is None:
+        parser.print_help()
+        sys.exit(1)
+
+    fn(args)
+
+
+if __name__ == "__main__":
+    main()