regard-cli 0.2.0__tar.gz

regard_cli-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - run: uv run --extra test pytest -v
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

regard_cli-0.2.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+.pytest_cache/
+data/trades.jsonl

regard_cli-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tab55
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

regard_cli-0.2.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: regard-cli
+Version: 0.2.0
+Summary: AI trading partner for the unified speculator — Hyperliquid + Polymarket
+Author: tab55
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,cli,defi,hyperliquid,polymarket,regard,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: hyperliquid-python-sdk>=0.22.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == 'test'
+Requires-Dist: syrupy>=4.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# regard-cli
+
+AI trading partner for the unified speculator. Multi-venue trading CLI consumed by the [regard-computer](https://github.com/akegaviar/tabtabtabTABtab) Claude Code skill.
+
+## Install
+
+```bash
+uv tool install regard-cli
+```
+
+## Usage
+
+```bash
+# Read commands (no auth needed)
+regard hl prices BTC ETH
+regard hl book BTC --depth 10
+regard hl assets TSLA
+regard hl funding BTC --history
+regard hl candles BTC 1h --limit 50
+
+# Account commands (needs HYPERLIQUID_AGENT_KEY or --address)
+regard hl status
+regard hl balance
+regard hl positions
+regard hl orders
+regard hl fills
+
+# Write commands (needs HYPERLIQUID_AGENT_KEY)
+regard hl order BTC buy 0.1 --market
+regard hl order BTC buy 0.1 95000 --tp 100000 --sl 90000
+regard hl cancel 77738308
+regard hl cancel-all BTC
+regard hl leverage BTC 10
+```
+
+## Auth
+
+Set `HYPERLIQUID_AGENT_KEY` env var with your Hyperliquid agent wallet key (can trade, cannot withdraw). Master address auto-resolved via `userRole` API.
+
+Read-only commands work without auth using `--address`.
+
+## Design
+
+- Venue-first sub-commands (`regard hl`, `regard poly`, ...)
+- Output envelope: `{"ok": true, "data": ..., "meta": {"timestamp": ...}}`
+- Structured errors with type/code/message, recovery hints, retryable flag
+- Exit codes: 0=success, 2=validation, 3=auth, 4=venue, 5=rate_limit, 6=network
+- Field projection via `--fields`
+- HIP-3 asset auto-resolution (e.g. `TSLA` → `xyz:TSLA`)
+- CLI-first, MCP-ready — every command maps 1:1 to an MCP tool definition
+
+## License
+
+MIT

regard_cli-0.2.0/README.md

@@ -0,0 +1,54 @@
+# regard-cli
+
+AI trading partner for the unified speculator. Multi-venue trading CLI consumed by the [regard-computer](https://github.com/akegaviar/tabtabtabTABtab) Claude Code skill.
+
+## Install
+
+```bash
+uv tool install regard-cli
+```
+
+## Usage
+
+```bash
+# Read commands (no auth needed)
+regard hl prices BTC ETH
+regard hl book BTC --depth 10
+regard hl assets TSLA
+regard hl funding BTC --history
+regard hl candles BTC 1h --limit 50
+
+# Account commands (needs HYPERLIQUID_AGENT_KEY or --address)
+regard hl status
+regard hl balance
+regard hl positions
+regard hl orders
+regard hl fills
+
+# Write commands (needs HYPERLIQUID_AGENT_KEY)
+regard hl order BTC buy 0.1 --market
+regard hl order BTC buy 0.1 95000 --tp 100000 --sl 90000
+regard hl cancel 77738308
+regard hl cancel-all BTC
+regard hl leverage BTC 10
+```
+
+## Auth
+
+Set `HYPERLIQUID_AGENT_KEY` env var with your Hyperliquid agent wallet key (can trade, cannot withdraw). Master address auto-resolved via `userRole` API.
+
+Read-only commands work without auth using `--address`.
+
+## Design
+
+- Venue-first sub-commands (`regard hl`, `regard poly`, ...)
+- Output envelope: `{"ok": true, "data": ..., "meta": {"timestamp": ...}}`
+- Structured errors with type/code/message, recovery hints, retryable flag
+- Exit codes: 0=success, 2=validation, 3=auth, 4=venue, 5=rate_limit, 6=network
+- Field projection via `--fields`
+- HIP-3 asset auto-resolution (e.g. `TSLA` → `xyz:TSLA`)
+- CLI-first, MCP-ready — every command maps 1:1 to an MCP tool definition
+
+## License
+
+MIT

regard_cli-0.2.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "regard-cli"
+version = "0.2.0"
+description = "AI trading partner for the unified speculator — Hyperliquid + Polymarket"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "tab55" }]
+readme = "README.md"
+keywords = ["regard", "trading", "cli", "agent", "hyperliquid", "polymarket", "defi"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = [
+    "typer>=0.9.0",
+    "hyperliquid-python-sdk>=0.22.0",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8.0", "syrupy>=4.0"]
+
+[project.scripts]
+regard = "hl_cli.main:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hl_cli"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

regard_cli-0.2.0/src/hl_cli/client.py

@@ -0,0 +1,98 @@
+"""SDK client factory — creates Info and Exchange instances."""
+
+import os
+
+import eth_account
+from hyperliquid.exchange import Exchange
+from hyperliquid.info import Info
+from hyperliquid.utils.constants import MAINNET_API_URL
+
+from hl_cli.output import die
+
+TESTNET_API_URL = "https://api.hyperliquid-testnet.xyz"
+
+
+def _base_url(testnet: bool) -> str:
+    return TESTNET_API_URL if testnet else MAINNET_API_URL
+
+
+def _get_key():
+    key = os.environ.get("HYPERLIQUID_AGENT_KEY") or os.environ.get("HYPERLIQUID_PRIVATE_KEY")
+    if not key:
+        die(
+            "auth_error", "NO_KEY",
+            "No trading key set",
+            hint="Set HYPERLIQUID_AGENT_KEY (agent wallet) or HYPERLIQUID_PRIVATE_KEY (master wallet)",
+            exit_code=3,
+        )
+    return key
+
+
+def _resolve_master_address(info: Info, agent_address: str) -> str:
+    """Look up the master account for an agent wallet via userRole API."""
+    try:
+        result = info.post("/info", {"type": "userRole", "user": agent_address})
+        role = result.get("role")
+        if role == "agent":
+            return result["data"]["user"]
+        if role == "user":
+            return agent_address  # key IS the master key
+    except Exception:
+        pass
+    return agent_address  # fallback: assume key is master
+
+
+def get_address(explicit: str = None, testnet: bool = False) -> str:
+    """Get account address for queries.
+
+    Priority: explicit arg > HYPERLIQUID_ACCOUNT_ADDRESS > auto-resolve via userRole API > derived from key.
+    """
+    if explicit:
+        return explicit
+    addr = os.environ.get("HYPERLIQUID_ACCOUNT_ADDRESS")
+    if addr:
+        return addr
+    key = os.environ.get("HYPERLIQUID_AGENT_KEY") or os.environ.get("HYPERLIQUID_PRIVATE_KEY")
+    if key:
+        agent_address = eth_account.Account.from_key(key).address
+        if os.environ.get("HYPERLIQUID_AGENT_KEY"):
+            info = Info(_base_url(testnet), skip_ws=True)
+            return _resolve_master_address(info, agent_address)
+        return agent_address
+    die(
+        "auth_error", "NO_ADDRESS",
+        "No address available",
+        hint="Set HYPERLIQUID_AGENT_KEY or use --address",
+        exit_code=3,
+    )
+
+
+def get_info(testnet: bool = False) -> Info:
+    """Create Info client (default perps only, dexes loaded lazily by resolver)."""
+    return Info(_base_url(testnet), skip_ws=True)
+
+
+def get_exchange(testnet: bool = False) -> Exchange:
+    """Create Exchange client.
+
+    Supports two modes:
+    - Agent mode: HYPERLIQUID_AGENT_KEY (signs) + HYPERLIQUID_ACCOUNT_ADDRESS (queries master account)
+    - Direct mode: HYPERLIQUID_PRIVATE_KEY (signs and queries same account)
+    """
+    key = _get_key()
+    wallet = eth_account.Account.from_key(key)
+    account_address = get_address()
+    return Exchange(wallet, _base_url(testnet), account_address=account_address)
+
+
+def get_all_mids(info: Info) -> dict:
+    """Get all mid prices including HIP-3 deployer assets."""
+    mids = info.all_mids()
+    try:
+        dex_list = info.post("/info", {"type": "perpDexs"})
+        for dex_info in dex_list[1:]:
+            dex_mids = info.post("/info", {"type": "allMids", "dex": dex_info["name"]})
+            mids.update(dex_mids)
+    except Exception:
+        pass
+    return mids

regard_cli-0.2.0/src/hl_cli/commands/act.py

@@ -0,0 +1,254 @@
+"""Act commands — order, cancel, cancel-all, leverage."""
+
+import sys
+from typing import Annotated, Optional
+
+import typer
+
+from hl_cli.client import get_address, get_exchange
+from hl_cli.main import hl_app
+from hl_cli.output import die, output
+from hl_cli.resolver import get_resolver
+
+SIDE_MAP = {"buy": True, "long": True, "sell": False, "short": False}
+
+
+def _parse_order_response(resp, asset: str, side_str: str, size: str):
+    """Parse SDK order response into CLI output format."""
+    if resp.get("status") == "err":
+        die("venue_error", "ORDER_REJECTED", resp.get("response", str(resp)), exit_code=4)
+
+    data = resp.get("response", {}).get("data", {})
+    statuses = data.get("statuses", [])
+    if not statuses:
+        die("venue_error", "ORDER_REJECTED", "No status in response", exit_code=4)
+
+    st = statuses[0]
+    if "error" in st:
+        die("venue_error", "ORDER_REJECTED", st["error"], exit_code=4)
+
+    if "filled" in st:
+        filled = st["filled"]
+        return {
+            "status": "filled",
+            "oid": filled.get("oid", 0),
+            "asset": asset,
+            "side": side_str,
+            "size": filled.get("totalSz", size),
+            "avg_price": filled.get("avgPx", ""),
+        }
+    elif "resting" in st:
+        resting = st["resting"]
+        return {
+            "status": "resting",
+            "oid": resting.get("oid", 0),
+            "asset": asset,
+            "side": side_str,
+            "size": size,
+        }
+    else:
+        return {"status": "unknown", "raw": st}
+
+
+
+@hl_app.command()
+def order(
+    ctx: typer.Context,
+    asset: Annotated[str, typer.Argument(help="Asset name")],
+    side: Annotated[str, typer.Argument(help="buy/long or sell/short")],
+    size: Annotated[str, typer.Argument(help="Amount in base asset")],
+    price: Annotated[Optional[str], typer.Argument(help="Limit price")] = None,
+    market: Annotated[bool, typer.Option("--market", help="Market order (IOC)")] = False,
+    tif: Annotated[Optional[str], typer.Option("--tif", help="gtc|ioc|alo")] = None,
+    reduce_only: Annotated[bool, typer.Option("--reduce-only", help="Reduce only")] = False,
+    tp: Annotated[Optional[str], typer.Option("--tp", help="Take profit trigger price")] = None,
+    sl: Annotated[Optional[str], typer.Option("--sl", help="Stop loss trigger price")] = None,
+    cloid: Annotated[Optional[str], typer.Option("--cloid", help="Client order ID (hex)")] = None,
+):
+    """Place an order."""
+    opts = ctx.obj
+
+    side_lower = side.lower()
+    if side_lower not in SIDE_MAP:
+        die("validation_error", "INVALID_SIDE", f"Invalid side: {side}", hint="Use buy/long or sell/short", param="side")
+
+    is_buy = SIDE_MAP[side_lower]
+    sz = float(size)
+
+    exchange = get_exchange(opts["testnet"])
+    resolver = get_resolver(exchange.info)
+    resolved = resolver.resolve(asset)
+
+    from hyperliquid.utils.types import Cloid as SdkCloid
+    sdk_cloid = SdkCloid.from_str(cloid) if cloid else None
+
+    if market or price is None:
+        # Market order
+        resp = exchange.market_open(resolved, is_buy, sz, cloid=sdk_cloid)
+        result = _parse_order_response(resp, resolved, side_lower, size)
+        output(result, opts["fields"])
+        return
+
+    # Limit order
+    px = float(price)
+    tif_val = (tif or "gtc").capitalize()
+    if tif_val == "Gtc":
+        tif_val = "Gtc"
+    elif tif_val == "Ioc":
+        tif_val = "Ioc"
+    elif tif_val == "Alo":
+        tif_val = "Alo"
+    order_type = {"limit": {"tif": tif_val}}
+
+    if tp or sl:
+        # Parent + TP/SL as grouped order
+        order_requests = [
+            {
+                "coin": resolved,
+                "is_buy": is_buy,
+                "sz": sz,
+                "limit_px": px,
+                "order_type": order_type,
+                "reduce_only": reduce_only,
+                "cloid": sdk_cloid,
+            }
+        ]
+        if tp:
+            tp_type = {"trigger": {"triggerPx": float(tp), "isMarket": True, "tpsl": "tp"}}
+            order_requests.append({
+                "coin": resolved,
+                "is_buy": not is_buy,
+                "sz": sz,
+                "limit_px": float(tp),
+                "order_type": tp_type,
+                "reduce_only": True,
+            })
+        if sl:
+            sl_type = {"trigger": {"triggerPx": float(sl), "isMarket": True, "tpsl": "sl"}}
+            order_requests.append({
+                "coin": resolved,
+                "is_buy": not is_buy,
+                "sz": sz,
+                "limit_px": float(sl),
+                "order_type": sl_type,
+                "reduce_only": True,
+            })
+
+        resp = exchange.bulk_orders(
+            [exchange._order_request_to_wire(r) for r in order_requests]
+            if hasattr(exchange, "_order_request_to_wire")
+            else order_requests,
+            grouping="normalTpsl",
+        )
+        result = _parse_order_response(resp, resolved, side_lower, size)
+        output(result, opts["fields"])
+    else:
+        resp = exchange.order(resolved, is_buy, sz, px, order_type, reduce_only, cloid=sdk_cloid)
+        result = _parse_order_response(resp, resolved, side_lower, size)
+        output(result, opts["fields"])
+
+
+@hl_app.command()
+def cancel(
+    ctx: typer.Context,
+    first: Annotated[str, typer.Argument(help="OID or asset name")],
+    second: Annotated[Optional[str], typer.Argument(help="OID (if first is asset)")] = None,
+    cloid: Annotated[Optional[str], typer.Option("--cloid", help="Cancel by client order ID")] = None,
+    asset_opt: Annotated[Optional[str], typer.Option("--asset", help="Asset for cloid cancel")] = None,
+):
+    """Cancel a specific order."""
+    opts = ctx.obj
+    exchange = get_exchange(opts["testnet"])
+
+    if cloid:
+        # Cancel by client order ID
+        if not asset_opt:
+            die("validation_error", "MISSING_ARGUMENT", "Must specify --asset with --cloid", hint="regard hl cancel --cloid 0x... --asset BTC")
+        resolver = get_resolver(exchange.info)
+        resolved = resolver.resolve(asset_opt)
+        from hyperliquid.utils.types import Cloid as SdkCloid
+        resp = exchange.cancel_by_cloid(resolved, SdkCloid.from_str(cloid))
+        output({"status": "cancelled", "asset": resolved, "cloid": cloid}, opts["fields"])
+        return
+
+    if second is not None:
+        # hl cancel BTC 77738308
+        resolver = get_resolver(exchange.info)
+        resolved = resolver.resolve(first)
+        oid = int(second)
+        exchange.cancel(resolved, oid)
+        output({"status": "cancelled", "oid": oid, "asset": resolved}, opts["fields"])
+    else:
+        # hl cancel 77738308 — auto-lookup asset from open orders
+        oid = int(first)
+        addr = get_address()
+        open_orders = exchange.info.open_orders(addr)
+        coin = None
+        for o in open_orders:
+            if o["oid"] == oid:
+                coin = o["coin"]
+                break
+        if not coin:
+            die("validation_error", "ORDER_NOT_FOUND", f"Order {oid} not found in open orders", hint=f"Pass asset explicitly: regard hl cancel BTC {oid}")
+        exchange.cancel(coin, oid)
+        output({"status": "cancelled", "oid": oid, "asset": coin}, opts["fields"])
+
+
+@hl_app.command(name="cancel-all")
+def cancel_all(
+    ctx: typer.Context,
+    asset: Annotated[Optional[str], typer.Argument(help="Cancel only this asset's orders")] = None,
+):
+    """Cancel all open orders."""
+    opts = ctx.obj
+    exchange = get_exchange(opts["testnet"])
+    addr = get_address()
+
+    open_orders = exchange.info.open_orders(addr)
+
+    if asset:
+        resolver = get_resolver(exchange.info)
+        resolved = resolver.resolve(asset)
+        open_orders = [o for o in open_orders if o["coin"] == resolved]
+
+    if not open_orders:
+        output({"cancelled": 0, "assets": []}, opts["fields"])
+        return
+
+    cancel_requests = [{"coin": o["coin"], "oid": o["oid"]} for o in open_orders]
+    exchange.bulk_cancel(cancel_requests)
+
+    assets_cancelled = sorted(set(o["coin"] for o in open_orders))
+    output({"cancelled": len(open_orders), "assets": assets_cancelled}, opts["fields"])
+
+
+@hl_app.command()
+def leverage(
+    ctx: typer.Context,
+    asset: Annotated[str, typer.Argument(help="Asset name")],
+    lev: Annotated[int, typer.Argument(help="Leverage (integer)")],
+    cross: Annotated[bool, typer.Option("--cross", help="Cross margin")] = False,
+    isolated: Annotated[bool, typer.Option("--isolated", help="Isolated margin")] = False,
+):
+    """Set leverage for an asset."""
+    opts = ctx.obj
+
+    if cross and isolated:
+        die("validation_error", "CONFLICTING_OPTIONS", "Cannot specify both --cross and --isolated")
+
+    exchange = get_exchange(opts["testnet"])
+    resolver = get_resolver(exchange.info)
+    resolved = resolver.resolve(asset)
+
+    is_cross = not isolated  # default is cross
+    if is_cross and ":" in resolved:
+        print("Warning: HIP-3 assets support isolated margin only. Using isolated.", file=sys.stderr)
+        is_cross = False
+
+    exchange.update_leverage(lev, resolved, is_cross)
+
+    output({
+        "asset": resolved,
+        "leverage": lev,
+        "margin_mode": "cross" if is_cross else "isolated",
+    }, opts["fields"])