trading-cli 0.3.0__py3-none-any.whl

fastbooks_cli/commands/repl.py

@@ -0,0 +1,385 @@
+"""REPL mode — interactive session with undo/redo and command history.
+
+Following CLI-Anything's ReplSkin pattern: persistent session state,
+structured command execution, and undo/redo for reversible operations.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import os
+import readline
+import shlex
+import sys
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+import click
+
+from ..client import FastBooksClient
+from ..output import emit, emit_error
+from .. import __version__
+
+
+@dataclass
+class SessionState:
+    """Tracks REPL session state for undo/redo."""
+    active_venue: str | None = None
+    active_symbol: str | None = None
+    active_bot_id: str | None = None
+    history: list[dict] = field(default_factory=list)
+    undo_stack: list[dict] = field(default_factory=list)
+    redo_stack: list[dict] = field(default_factory=list)
+    aliases: dict[str, str] = field(default_factory=dict)
+    variables: dict[str, str] = field(default_factory=dict)
+
+    def snapshot(self) -> dict:
+        return {
+            "active_venue": self.active_venue,
+            "active_symbol": self.active_symbol,
+            "active_bot_id": self.active_bot_id,
+        }
+
+    def restore(self, snap: dict) -> None:
+        self.active_venue = snap.get("active_venue")
+        self.active_symbol = snap.get("active_symbol")
+        self.active_bot_id = snap.get("active_bot_id")
+
+    def push_undo(self, action: dict) -> None:
+        self.undo_stack.append({"state": self.snapshot(), "action": action})
+        self.redo_stack.clear()
+
+    def undo(self) -> dict | None:
+        if not self.undo_stack:
+            return None
+        entry = self.undo_stack.pop()
+        self.redo_stack.append({"state": self.snapshot(), "action": entry["action"]})
+        self.restore(entry["state"])
+        return entry["action"]
+
+    def redo(self) -> dict | None:
+        if not self.redo_stack:
+            return None
+        entry = self.redo_stack.pop()
+        self.undo_stack.append({"state": self.snapshot(), "action": entry["action"]})
+        self.restore(entry["state"])
+        return entry["action"]
+
+
+# ── REPL built-in commands ───────────────────────────────────────────────
+
+BUILTINS_HELP = """
+  Built-in Commands:
+  ==================
+  help / ?           Show this help
+  exit / quit / q    Exit REPL
+  undo               Undo last state change
+  redo               Redo last undone change
+  history            Show command history
+  status             Show current session state
+  use <venue>        Set active venue (e.g. 'use binance')
+  symbol <sym>       Set active symbol (e.g. 'symbol BTC/USDT')
+  bot <id>           Set active bot ID
+  alias <name> <cmd> Create command alias
+  unalias <name>     Remove alias
+  aliases            List all aliases
+  set <key> <val>    Set a session variable
+  vars               List session variables
+  clear              Clear screen
+  json on/off        Toggle JSON output mode
+
+  CLI Commands:
+  =============
+  Any 'fastbooks' command works without the 'fastbooks' prefix:
+    markets orderbook binance BTC/USDT
+    execute balance binance
+    bots list
+    swap jupiter SOL USDC 1.0
+
+  Context-Aware Shortcuts:
+  ========================
+  After 'use binance' + 'symbol BTC/USDT':
+    orderbook          -> markets orderbook binance BTC/USDT
+    balance            -> execute balance binance
+    order buy market 1 -> execute order binance BTC/USDT buy market 1
+"""
+
+
+def _banner() -> str:
+    return f"""
+  ╔══════════════════════════════════════════════════╗
+  ║  FastBooks REPL v{__version__:<36}║
+  ║  Agent-native interactive trading session        ║
+  ║  Type 'help' for commands, 'exit' to quit        ║
+  ╚══════════════════════════════════════════════════╝
+
+  SKILL.md: {os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'SKILL.md'))}
+"""
+
+
+@click.command("repl")
+@click.option("--venue", "-v", default=None, help="Start with an active venue.")
+@click.option("--symbol", "-s", default=None, help="Start with an active symbol.")
+@click.pass_context
+def repl(ctx, venue, symbol):
+    """Start an interactive REPL session.
+
+    Provides a persistent session with context-aware shortcuts,
+    undo/redo, command history, and aliases.
+
+    Examples:
+        fastbooks repl
+        fastbooks repl --venue binance --symbol BTC/USDT
+    """
+    from ..main import cli as root_cli
+
+    client: FastBooksClient = ctx.obj
+    state = SessionState(active_venue=venue, active_symbol=symbol)
+    json_mode = ctx.find_root().params.get("json_output", False)
+
+    # Setup readline history
+    histfile = os.path.expanduser("~/.fastbooks_history")
+    try:
+        readline.read_history_file(histfile)
+    except FileNotFoundError:
+        pass
+    readline.set_history_length(1000)
+
+    click.echo(_banner())
+
+    if state.active_venue:
+        click.echo(f"  Active venue: {state.active_venue}")
+    if state.active_symbol:
+        click.echo(f"  Active symbol: {state.active_symbol}")
+    click.echo()
+
+    while True:
+        # Build prompt
+        prompt_parts = ["fastbooks"]
+        if state.active_venue:
+            prompt_parts.append(state.active_venue)
+        if state.active_symbol:
+            prompt_parts.append(state.active_symbol)
+        prompt = ":".join(prompt_parts) + "> "
+
+        try:
+            line = input(prompt).strip()
+        except (EOFError, KeyboardInterrupt):
+            click.echo("\n  Goodbye.")
+            break
+
+        if not line:
+            continue
+
+        # Save to readline history
+        state.history.append({"command": line, "timestamp": time.time()})
+
+        # Resolve aliases
+        parts = line.split(None, 1)
+        cmd = parts[0].lower()
+        rest = parts[1] if len(parts) > 1 else ""
+
+        if cmd in state.aliases:
+            line = state.aliases[cmd] + (" " + rest if rest else "")
+            parts = line.split(None, 1)
+            cmd = parts[0].lower()
+            rest = parts[1] if len(parts) > 1 else ""
+
+        # ── built-ins ────────────────────────────────────────────────
+
+        if cmd in ("exit", "quit", "q"):
+            click.echo("  Goodbye.")
+            break
+
+        elif cmd in ("help", "?"):
+            click.echo(BUILTINS_HELP)
+            continue
+
+        elif cmd == "undo":
+            action = state.undo()
+            if action:
+                click.echo(f"  Undone: {action.get('description', '?')}")
+            else:
+                click.echo("  Nothing to undo.")
+            continue
+
+        elif cmd == "redo":
+            action = state.redo()
+            if action:
+                click.echo(f"  Redone: {action.get('description', '?')}")
+            else:
+                click.echo("  Nothing to redo.")
+            continue
+
+        elif cmd == "history":
+            for i, h in enumerate(state.history[-20:], 1):
+                click.echo(f"  {i:3}  {h['command']}")
+            continue
+
+        elif cmd == "status":
+            click.echo(f"  Venue:  {state.active_venue or '(none)'}")
+            click.echo(f"  Symbol: {state.active_symbol or '(none)'}")
+            click.echo(f"  Bot:    {state.active_bot_id or '(none)'}")
+            click.echo(f"  JSON:   {'on' if json_mode else 'off'}")
+            click.echo(f"  Undo:   {len(state.undo_stack)} actions")
+            click.echo(f"  Redo:   {len(state.redo_stack)} actions")
+            continue
+
+        elif cmd == "use":
+            old = state.active_venue
+            state.push_undo({"description": f"use {old} -> {rest}", "type": "venue"})
+            state.active_venue = rest.strip() if rest.strip() else None
+            click.echo(f"  Venue set to: {state.active_venue or '(none)'}")
+            continue
+
+        elif cmd == "symbol":
+            old = state.active_symbol
+            state.push_undo({"description": f"symbol {old} -> {rest}", "type": "symbol"})
+            state.active_symbol = rest.strip() if rest.strip() else None
+            click.echo(f"  Symbol set to: {state.active_symbol or '(none)'}")
+            continue
+
+        elif cmd == "bot":
+            old = state.active_bot_id
+            state.push_undo({"description": f"bot {old} -> {rest}", "type": "bot"})
+            state.active_bot_id = rest.strip() if rest.strip() else None
+            click.echo(f"  Bot set to: {state.active_bot_id or '(none)'}")
+            continue
+
+        elif cmd == "alias":
+            alias_parts = rest.split(None, 1)
+            if len(alias_parts) < 2:
+                click.echo("  Usage: alias <name> <command>")
+                continue
+            state.aliases[alias_parts[0]] = alias_parts[1]
+            click.echo(f"  Alias '{alias_parts[0]}' -> '{alias_parts[1]}'")
+            continue
+
+        elif cmd == "unalias":
+            name = rest.strip()
+            if name in state.aliases:
+                del state.aliases[name]
+                click.echo(f"  Removed alias '{name}'.")
+            else:
+                click.echo(f"  No alias '{name}'.")
+            continue
+
+        elif cmd == "aliases":
+            if not state.aliases:
+                click.echo("  No aliases defined.")
+            else:
+                for name, target in state.aliases.items():
+                    click.echo(f"  {name} -> {target}")
+            continue
+
+        elif cmd == "set":
+            set_parts = rest.split(None, 1)
+            if len(set_parts) < 2:
+                click.echo("  Usage: set <key> <value>")
+                continue
+            state.variables[set_parts[0]] = set_parts[1]
+            click.echo(f"  {set_parts[0]} = {set_parts[1]}")
+            continue
+
+        elif cmd == "vars":
+            if not state.variables:
+                click.echo("  No variables set.")
+            else:
+                for k, v in state.variables.items():
+                    click.echo(f"  {k} = {v}")
+            continue
+
+        elif cmd == "clear":
+            click.clear()
+            continue
+
+        elif cmd == "json":
+            if rest.strip().lower() in ("on", "true", "1"):
+                json_mode = True
+                click.echo("  JSON output: on")
+            elif rest.strip().lower() in ("off", "false", "0"):
+                json_mode = False
+                click.echo("  JSON output: off")
+            else:
+                click.echo(f"  JSON output: {'on' if json_mode else 'off'}")
+            continue
+
+        # ── context-aware shortcuts ──────────────────────────────────
+
+        expanded = _expand_shortcut(line, state)
+        if expanded != line:
+            click.secho(f"  -> {expanded}", fg="cyan")
+            line = expanded
+
+        # ── execute as CLI command ───────────────────────────────────
+
+        try:
+            args = shlex.split(line)
+        except ValueError as e:
+            click.secho(f"  Parse error: {e}", fg="red")
+            continue
+
+        if json_mode and "--json" not in args:
+            args = ["--json"] + args
+
+        try:
+            root_cli(args, standalone_mode=False, obj=client)
+        except SystemExit:
+            pass
+        except click.exceptions.UsageError as e:
+            click.secho(f"  {e}", fg="red")
+        except Exception as e:
+            click.secho(f"  Error: {e}", fg="red")
+
+        click.echo()
+
+    # Save history
+    try:
+        readline.write_history_file(histfile)
+    except OSError:
+        pass
+
+
+def _expand_shortcut(line: str, state: SessionState) -> str:
+    """Expand context-aware shortcuts using active venue/symbol."""
+    parts = line.split()
+    if not parts:
+        return line
+
+    cmd = parts[0].lower()
+
+    # Direct command shortcuts when venue/symbol are set
+    if cmd == "orderbook" and state.active_venue and state.active_symbol:
+        return f"markets orderbook {state.active_venue} {state.active_symbol}"
+
+    if cmd == "balance" and state.active_venue:
+        extra = " ".join(parts[1:])
+        return f"execute balance {state.active_venue}" + (f" {extra}" if extra else "")
+
+    if cmd == "positions" and state.active_venue:
+        return f"execute positions {state.active_venue}"
+
+    if cmd == "orders" and state.active_venue:
+        extra = " ".join(parts[1:])
+        return f"execute orders {state.active_venue}" + (f" {extra}" if extra else "")
+
+    if cmd == "order" and state.active_venue and state.active_symbol and len(parts) >= 4:
+        # order buy market 0.01 -> execute order <venue> <symbol> buy market 0.01
+        extra = " ".join(parts[1:])
+        return f"execute order {state.active_venue} {state.active_symbol} {extra}"
+
+    if cmd == "ohlcv" and state.active_venue and state.active_symbol:
+        extra = " ".join(parts[1:])
+        return f"markets ohlcv {state.active_venue} {state.active_symbol}" + (f" {extra}" if extra else "")
+
+    if cmd == "tickers" and state.active_venue:
+        extra = " ".join(parts[1:])
+        return f"markets tickers --exchange {state.active_venue}" + (f" {extra}" if extra else "")
+
+    # Bot shortcuts
+    if cmd in ("start", "stop", "pause", "resume", "logs", "events", "report", "rebalance") and state.active_bot_id and len(parts) == 1:
+        return f"bots {cmd} {state.active_bot_id}"
+
+    return line

fastbooks_cli/commands/strategy.py

@@ -0,0 +1,259 @@
+"""Strategy command group — run local trading bots from the CLI.
+
+Unlike ``bots`` (cloud-managed), strategies are local Python modules
+that run in-process. They are shipped as a separate, optionally-installed
+plugin package (``fastbooks-clistrategies``) and discovered at runtime via
+the ``fastbooks_cli.strategies`` entry point.
+
+Usage:
+    fastbooks strategy list
+    fastbooks strategy info hl-momentum-hunter
+    fastbooks strategy run hl-momentum-hunter --private-key 0x... --account 0x...
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+
+import click
+
+from ..output import emit, emit_error, format_table
+from ..strategies import REGISTRY
+
+
+@click.group()
+def strategy():
+    """Local trading strategies — run bots directly from the CLI.
+
+    Strategies are self-contained trading algorithms that run in-process.
+    Keys are passed via CLI flags or environment variables — never hardcoded.
+
+    Examples:
+        fastbooks strategy list
+        fastbooks strategy info hl-momentum-hunter
+        fastbooks strategy run hl-momentum-hunter --private-key $HL_PRIVATE_KEY --account $HL_ACCOUNT
+    """
+    pass
+
+
+# ── list ─────────────────────────────────────────────────────────────────
+
+@strategy.command("list")
+@click.pass_context
+def strategy_list(ctx):
+    """List all available strategies.
+
+    Example: fastbooks strategy list
+    """
+    rows = []
+    for slug, meta in REGISTRY.items():
+        rows.append({
+            "slug": slug,
+            "name": meta.name,
+            "venue": meta.venue,
+            "description": meta.description,
+        })
+
+    data = {"strategies": rows}
+    emit(ctx, data, lambda d: _format_strategy_list(d))
+
+
+def _format_strategy_list(data) -> str:
+    items = data.get("strategies", [])
+    if not items:
+        return "  No strategies registered."
+    return format_table(
+        items,
+        ["slug", "name", "venue", "description"],
+        ["Slug", "Name", "Venue", "Description"],
+    )
+
+
+# ── info ─────────────────────────────────────────────────────────────────
+
+@strategy.command("info")
+@click.argument("slug")
+@click.pass_context
+def strategy_info(ctx, slug):
+    """Show details for a strategy.
+
+    Example: fastbooks strategy info hl-momentum-hunter
+    """
+    meta = REGISTRY.get(slug)
+    if not meta:
+        emit_error(ctx, f"Unknown strategy: {slug}")
+        ctx.exit(1)
+        return
+
+    data = {
+        "slug": meta.slug,
+        "name": meta.name,
+        "venue": meta.venue,
+        "description": meta.description,
+        "required_keys": meta.required_keys,
+        "optional_keys": meta.optional_keys,
+        "module": meta.module,
+    }
+    emit(ctx, data, lambda d: _format_strategy_info(d))
+
+
+def _format_strategy_info(data) -> str:
+    lines = [
+        f"\n  {data['name']}",
+        f"  Slug:    {data['slug']}",
+        f"  Venue:   {data['venue']}",
+        f"  Module:  {data['module']}",
+        f"  {data['description']}",
+        "",
+        "  Required keys (via --private-key/--account or env vars):",
+    ]
+    for k in data["required_keys"]:
+        lines.append(f"    - {k}")
+    if data.get("optional_keys"):
+        lines.append("  Optional:")
+        for k in data["optional_keys"]:
+            lines.append(f"    - {k}")
+    return "\n".join(lines)
+
+
+# ── run ──────────────────────────────────────────────────────────────────
+
+@strategy.command("run")
+@click.argument("slug")
+@click.option(
+    "--private-key", envvar="HL_PRIVATE_KEY", default=None,
+    help="Wallet private key (or set HL_PRIVATE_KEY).",
+)
+@click.option(
+    "--account", envvar="HL_ACCOUNT_ADDRESS", default=None,
+    help="Main account address (or set HL_ACCOUNT_ADDRESS).",
+)
+@click.option("--testnet", is_flag=True, envvar="HL_TESTNET", help="Use testnet.")
+@click.option(
+    "--config-json", type=str, default=None,
+    help="Override strategy params as JSON string.",
+)
+@click.option(
+    "--config-file", type=click.Path(exists=True), default=None,
+    help="Override strategy params from a JSON file.",
+)
+@click.option(
+    "--confirm/--no-confirm", default=True,
+    help="Require confirmation before live trading.",
+)
+@click.pass_context
+def strategy_run(ctx, slug, private_key, account, testnet, config_json, config_file, confirm):
+    """Run a strategy.
+
+    Keys are passed via flags or environment variables. Strategy-specific
+    parameters can be overridden with --config-json or --config-file.
+
+    Examples:
+        fastbooks strategy run hl-momentum-hunter \\
+            --private-key 0x... --account 0x...
+
+        # With env vars:
+        export HL_PRIVATE_KEY=0x...
+        export HL_ACCOUNT_ADDRESS=0x...
+        fastbooks strategy run hl-momentum-hunter
+
+        # Testnet + custom params:
+        fastbooks strategy run hl-momentum-hunter --testnet \\
+            --config-json '{"max_order_usd": 100, "max_leverage": 3}'
+
+        # From config file:
+        fastbooks strategy run hl-momentum-hunter \\
+            --config-file my_settings.json
+    """
+    meta = REGISTRY.get(slug)
+    if not meta:
+        emit_error(ctx, f"Unknown strategy: {slug}")
+        if REGISTRY:
+            emit_error(ctx, f"Available: {', '.join(REGISTRY.keys())}")
+        else:
+            emit_error(ctx, "No strategies installed. Install the plugin package: pip install fastbooks-clistrategies")
+        ctx.exit(1)
+        return
+
+    # Build config dict
+    cfg: dict = {}
+
+    # Load config file first (lowest priority)
+    if config_file:
+        try:
+            with open(config_file) as f:
+                cfg.update(json.load(f))
+        except (json.JSONDecodeError, OSError) as e:
+            emit_error(ctx, f"Config file error: {e}")
+            ctx.exit(1)
+            return
+
+    # Overlay JSON string (higher priority)
+    if config_json:
+        try:
+            cfg.update(json.loads(config_json))
+        except json.JSONDecodeError as e:
+            emit_error(ctx, f"Invalid JSON: {e}")
+            ctx.exit(1)
+            return
+
+    # Auth keys (highest priority — CLI flags / env vars)
+    if private_key:
+        cfg["private_key"] = private_key
+    if account:
+        cfg["account_address"] = account
+    cfg["use_testnet"] = testnet
+
+    # Validate required keys
+    missing = []
+    key_map = {
+        "HL_PRIVATE_KEY": "private_key",
+        "HL_ACCOUNT_ADDRESS": "account_address",
+    }
+    for env_name in meta.required_keys:
+        cfg_key = key_map.get(env_name, env_name.lower())
+        if not cfg.get(cfg_key):
+            # Try env var as fallback
+            env_val = os.environ.get(env_name)
+            if env_val:
+                cfg[cfg_key] = env_val
+            else:
+                missing.append(env_name)
+
+    if missing:
+        emit_error(ctx, f"Missing required keys: {', '.join(missing)}")
+        emit_error(ctx, "Pass via CLI flags or set as environment variables.")
+        ctx.exit(1)
+        return
+
+    # Safety confirmation for mainnet
+    if not testnet and confirm:
+        click.echo(f"\n  Strategy:  {meta.name}")
+        click.echo(f"  Venue:     {meta.venue}")
+        click.echo(f"  Network:   MAINNET")
+        click.echo(f"  Account:   {cfg.get('account_address', '?')}")
+        if not click.confirm("\n  Start live trading?"):
+            click.echo("  Cancelled.")
+            return
+
+    # Run
+    import importlib
+
+    try:
+        mod = importlib.import_module(meta.module)
+    except ImportError as e:
+        emit_error(ctx, f"Cannot import strategy: {e}")
+        emit_error(
+            ctx,
+            "Install the strategy plugin and its deps: pip install fastbooks-clistrategies",
+        )
+        ctx.exit(1)
+        return
+
+    click.echo(f"\n  Starting {meta.name}...")
+    try:
+        asyncio.run(mod.run(cfg))
+    except KeyboardInterrupt:
+        click.echo("\n  Strategy stopped.")