fere-cli 0.1.0.dev6__py3-none-any.whl

fere_cli/__init__.py

@@ -0,0 +1,3 @@
+"""FereAI CLI — terminal interface for crypto trading and research."""
+
+__version__ = "0.1.0"

fere_cli/async_util.py

@@ -0,0 +1,63 @@
+"""Async bridge utilities for the CLI.
+
+Click commands are synchronous; the SDK is async. This module
+bridges the two with a thin ``run_async`` wrapper and a
+``get_client`` factory.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from functools import wraps
+from typing import Any, Callable
+
+import click
+from fere_sdk import FereClient
+
+from .config import load_config
+
+
+def run_async(coro):
+    """Run an async coroutine from synchronous context."""
+    return asyncio.run(coro)
+
+
+def async_command(f: Callable) -> Callable:
+    """Decorator: wraps an async function for use as a Click command."""
+
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        return run_async(f(*args, **kwargs))
+
+    return wrapper
+
+
+async def get_client(ctx: click.Context) -> FereClient:
+    """Create an authenticated FereClient from config + CLI overrides.
+
+    Raises click.ClickException if no agent name is configured.
+    """
+    cfg = load_config()
+
+    # CLI flag overrides
+    agent_name = ctx.obj.get("agent_override") or cfg.get("agent_name")
+    base_url = ctx.obj.get("base_url_override") or cfg.get("base_url")
+    key_path = cfg.get("key_path")
+
+    if not agent_name:
+        raise click.ClickException(
+            "No agent configured. Run 'fere auth' first "
+            "or pass --agent NAME."
+        )
+
+    return await FereClient.create(
+        agent_name=agent_name,
+        base_url=base_url,
+        key_path=key_path,
+    )
+
+
+def is_tty() -> bool:
+    """Check if stdin is a TTY (interactive terminal)."""
+    return sys.stdin.isatty()

fere_cli/banner.py

@@ -0,0 +1,23 @@
+"""ASCII art banner for the Fere CLI."""
+
+from . import __version__
+
+# Simplified spiral motif + stylized "FERE AI" text
+# The spiral evokes the Fere AI logo's concentric swirl pattern
+# Kept under 70 chars wide for comfortable 80-col terminal display
+LOGO = r"""
+     . · .
+   ·       ·      _____ _____ ____  _____      _    ___
+  ·  . · .  ·    |  ___|  ___|  _ \| ____|    / \  |_ _|
+ ·  ·     ·  ·   | |_  | |_  | |_) |  _|     / _ \  | |
+ ·  ·  .  ·  ·   |  _| |  _| |  _ <| |___   / ___ \ | |
+ ·  ·     ·  ·   |_|   |___|_|_| \_\_____|  /_/   \_\___|
+  ·  · . ·  ·
+   ·       ·
+     · . ·
+"""
+
+
+def get_banner() -> str:
+    """Return the full banner string with version."""
+    return f"{LOGO}\n  v{__version__} — crypto trading & research from your terminal\n"

fere_cli/commands/auth.py

@@ -0,0 +1,108 @@
+"""Auth commands: fere auth, fere whoami, fere credits."""
+
+from __future__ import annotations
+
+import click
+from fere_sdk import FereClient
+from rich.console import Console
+
+from ..async_util import async_command, get_client, is_tty, run_async
+from ..config import load_config, save_config
+from ..output import print_error, print_success
+
+console = Console()
+
+
+@click.command()
+@click.option("--name", prompt=False, default=None, help="Agent name.")
+@click.pass_context
+@async_command
+async def auth(ctx, name: str | None):
+    """Authenticate and register a new agent (first-run setup)."""
+    cfg = load_config()
+
+    agent_name = (
+        ctx.obj.get("agent_override")
+        or name
+        or cfg.get("agent_name")
+    )
+    if not agent_name:
+        if is_tty():
+            agent_name = click.prompt("Agent name")
+        else:
+            raise click.ClickException(
+                "Agent name required. Pass --name or --agent."
+            )
+
+    base_url = ctx.obj.get("base_url_override") or cfg.get("base_url")
+    key_path = cfg.get("key_path")
+
+    try:
+        client = await FereClient.create(
+            agent_name=agent_name,
+            base_url=base_url,
+            key_path=key_path,
+        )
+
+        # Persist agent name to config
+        cfg["agent_name"] = agent_name
+        save_config(cfg)
+
+        user = await client.get_user()
+        await client.close()
+
+        print_success(
+            {
+                "status": "authenticated",
+                "agent_name": agent_name,
+                "user": user,
+            },
+            quiet_value=agent_name,
+        )
+    except Exception as e:
+        print_error(f"Authentication failed: {e}")
+        raise SystemExit(1)
+
+
+@click.command()
+@click.pass_context
+@async_command
+async def whoami(ctx):
+    """Show current agent identity and wallet addresses."""
+    try:
+        client = await get_client(ctx)
+        user = await client.get_user()
+        wallets_data = await client.get_wallets()
+        await client.close()
+
+        result = {**user}
+        if wallets_data:
+            result["wallets"] = wallets_data
+
+        print_success(result)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+
+@click.command()
+@click.pass_context
+@async_command
+async def credits(ctx):
+    """Show available credit balance."""
+    try:
+        client = await get_client(ctx)
+        balance = await client.get_credits()
+        await client.close()
+
+        print_success(
+            {"credits_available": balance},
+            quiet_value=str(balance),
+        )
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)

fere_cli/commands/chat.py

@@ -0,0 +1,198 @@
+"""Chat commands: fere chat, fere threads."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import click
+from rich.console import Console
+
+from ..async_util import async_command, get_client, is_tty
+from ..output import (
+    is_json_mode,
+    print_error,
+    print_streaming_text,
+    print_success,
+    print_table_from_dicts,
+)
+
+console = Console()
+
+
+@click.command()
+@click.argument("query", required=False, default=None)
+@click.option(
+    "--stream",
+    "stream_mode",
+    is_flag=True,
+    default=False,
+    help="Stream response events as they arrive.",
+)
+@click.option(
+    "--thread",
+    "thread_id",
+    default=None,
+    help="Continue an existing chat thread.",
+)
+@click.option(
+    "--agent",
+    "agent_type",
+    default="ProAgent",
+    help="Agent type to use (default: ProAgent).",
+)
+@click.pass_context
+@async_command
+async def chat(ctx, query, stream_mode, thread_id, agent_type):
+    """Chat with FereAI's crypto AI agent.
+
+    Pass a query as an argument for one-shot mode, or run without
+    arguments to enter interactive REPL mode.
+    """
+    try:
+        client = await get_client(ctx)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    try:
+        if query:
+            # One-shot mode
+            if stream_mode:
+                await _stream_chat(
+                    client, query, thread_id, agent_type
+                )
+            else:
+                await _oneshot_chat(
+                    client, query, thread_id, agent_type
+                )
+        elif is_tty():
+            # Interactive REPL
+            await _repl_chat(client, thread_id, agent_type)
+        else:
+            raise click.ClickException(
+                "Query required in non-interactive mode. "
+                "Usage: fere chat \"your question\""
+            )
+    except click.ClickException:
+        raise
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)
+    finally:
+        await client.close()
+
+
+async def _oneshot_chat(client, query, thread_id, agent_type):
+    """Send a query and print the final answer."""
+    result = await client.chat(
+        query, thread_id=thread_id, agent=agent_type
+    )
+    print_success(
+        result,
+        quiet_value=result.get("answer", ""),
+    )
+
+
+async def _stream_chat(client, query, thread_id, agent_type):
+    """Stream chat events, printing each as it arrives."""
+    json_mode = is_json_mode()
+
+    async for event in client.chat_stream(
+        query, thread_id=thread_id, agent=agent_type
+    ):
+        if json_mode:
+            # NDJSON: one JSON object per line
+            click.echo(
+                json.dumps(
+                    {"event": event.event, "data": event.data},
+                    default=str,
+                )
+            )
+        else:
+            if event.event == "chunk":
+                text = event.data.get("text", "")
+                print_streaming_text(text)
+            elif event.event == "answer":
+                text = event.data.get("text", "")
+                if text:
+                    click.echo()  # newline after chunks
+                    console.print(
+                        f"\n[bold]Answer:[/bold] {text}"
+                    )
+            elif event.event == "tool_response":
+                console.print(
+                    f"[dim]Tool: {json.dumps(event.data, default=str)}[/dim]"
+                )
+            elif event.event == "error":
+                msg = event.data.get("message", str(event.data))
+                print_error(msg)
+            elif event.event == "meta":
+                chat_id = event.data.get("chat_id", "")
+                console.print(f"[dim]Chat: {chat_id}[/dim]")
+
+    if not json_mode:
+        click.echo()  # final newline
+
+
+async def _repl_chat(client, thread_id, agent_type):
+    """Interactive REPL loop."""
+    console.print(
+        "[bold]FereAI Chat[/bold] "
+        "[dim](type /exit or Ctrl+D to quit)[/dim]\n"
+    )
+
+    current_thread = thread_id
+
+    while True:
+        try:
+            query = input(">>> ")
+        except EOFError:
+            click.echo()
+            break
+
+        query = query.strip()
+        if not query:
+            continue
+        if query in ("/exit", "/quit"):
+            break
+
+        result = await client.chat(
+            query, thread_id=current_thread, agent=agent_type
+        )
+
+        # Track thread for continuity
+        if "chat_id" in result and not current_thread:
+            current_thread = result["chat_id"]
+
+        answer = result.get("answer", "")
+        if answer:
+            console.print(f"\n{answer}\n")
+
+
+@click.command()
+@click.option(
+    "--limit",
+    default=10,
+    help="Number of threads to show.",
+)
+@click.option("--skip", default=0, help="Offset.")
+@click.pass_context
+@async_command
+async def threads(ctx, limit, skip):
+    """List recent chat threads."""
+    try:
+        client = await get_client(ctx)
+        data = await client.get_threads(skip=skip, limit=limit)
+        await client.close()
+
+        print_success(data)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)

fere_cli/commands/earn.py

@@ -0,0 +1,143 @@
+"""Earn commands: fere earn (info, deposit, withdraw, positions)."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from ..async_util import async_command, get_client, is_tty
+from ..output import print_error, print_success
+
+console = Console()
+
+
+@click.group()
+def earn():
+    """Manage yield earning (deposit, withdraw, view APY)."""
+    pass
+
+
+@earn.command()
+@click.pass_context
+@async_command
+async def info(ctx):
+    """Show current APY and vault details."""
+    try:
+        client = await get_client(ctx)
+        data = await client.get_earn_info()
+        await client.close()
+
+        print_success(data)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+
+@earn.command()
+@click.option(
+    "--amount",
+    required=True,
+    type=float,
+    help="USDC amount to deposit.",
+)
+@click.option(
+    "--position-id",
+    default=None,
+    help="Existing position ID to add to.",
+)
+@click.option(
+    "--timeout", default=120, type=int, help="Wait timeout (seconds)."
+)
+@click.option("-y", "--yes", is_flag=True, help="Skip confirmation.")
+@click.pass_context
+@async_command
+async def deposit(ctx, amount, position_id, timeout, yes):
+    """Deposit USDC to earn yield."""
+    if not yes and is_tty():
+        click.echo(f"Deposit {amount} USDC into Fere Earn")
+        if not click.confirm("Proceed?"):
+            raise SystemExit(0)
+
+    try:
+        client = await get_client(ctx)
+
+        with console.status("Processing deposit..."):
+            result = await client.deposit(
+                amount_usdc=amount,
+                position_id=position_id,
+                timeout=timeout,
+            )
+
+        await client.close()
+        print_success(result)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+
+@earn.command()
+@click.option(
+    "--position-id",
+    required=True,
+    help="Position ID to withdraw from.",
+)
+@click.option(
+    "--amount",
+    required=True,
+    type=float,
+    help="USDC amount to withdraw.",
+)
+@click.option(
+    "--timeout", default=120, type=int, help="Wait timeout (seconds)."
+)
+@click.option("-y", "--yes", is_flag=True, help="Skip confirmation.")
+@click.pass_context
+@async_command
+async def withdraw(ctx, position_id, amount, timeout, yes):
+    """Withdraw USDC from a yield position."""
+    if not yes and is_tty():
+        click.echo(
+            f"Withdraw {amount} USDC from position {position_id}"
+        )
+        if not click.confirm("Proceed?"):
+            raise SystemExit(0)
+
+    try:
+        client = await get_client(ctx)
+
+        with console.status("Processing withdrawal..."):
+            result = await client.withdraw(
+                position_id=position_id,
+                amount_usdc=amount,
+                timeout=timeout,
+            )
+
+        await client.close()
+        print_success(result)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+
+@earn.command()
+@click.pass_context
+@async_command
+async def positions(ctx):
+    """Show active yield positions."""
+    try:
+        client = await get_client(ctx)
+        data = await client.get_positions()
+        await client.close()
+
+        print_success(data)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)

fere_cli/commands/hooks.py

@@ -0,0 +1,74 @@
+"""Hooks commands: fere hooks set."""
+
+from __future__ import annotations
+
+import json
+
+import click
+
+from ..async_util import async_command, get_client
+from ..output import print_error, print_success
+
+
+@click.group()
+def hooks():
+    """Manage stop-loss and take-profit hooks."""
+    pass
+
+
+@hooks.command()
+@click.option(
+    "--chain-id", required=True, type=int, help="Chain ID."
+)
+@click.option(
+    "--token", required=True, help="Token contract address."
+)
+@click.option(
+    "--stop-loss",
+    default=None,
+    help="Stop-loss config as JSON (e.g. '{\"price\": 1.5}').",
+)
+@click.option(
+    "--take-profit",
+    default=None,
+    help="Take-profit config as JSON (e.g. '{\"price\": 3.0}').",
+)
+@click.pass_context
+@async_command
+async def set(ctx, chain_id, token, stop_loss, take_profit):
+    """Set stop-loss and/or take-profit hooks on a token."""
+    try:
+        sl = json.loads(stop_loss) if stop_loss else None
+    except json.JSONDecodeError as exc:
+        raise click.BadParameter(
+            f"Invalid JSON for --stop-loss: {exc}", param_hint="'--stop-loss'"
+        )
+    try:
+        tp = json.loads(take_profit) if take_profit else None
+    except json.JSONDecodeError as exc:
+        raise click.BadParameter(
+            f"Invalid JSON for --take-profit: {exc}",
+            param_hint="'--take-profit'",
+        )
+
+    if not sl and not tp:
+        raise click.ClickException(
+            "At least one of --stop-loss or --take-profit is required."
+        )
+
+    try:
+        client = await get_client(ctx)
+        result = await client.set_hooks(
+            chain_id=chain_id,
+            token_address=token,
+            stop_loss=sl,
+            take_profit=tp,
+        )
+        await client.close()
+
+        print_success(result)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)