fere-cli 0.2.0.dev17__py3-none-any.whl → 0.2.1.dev19__py3-none-any.whl

fere_cli/__init__.py

@@ -1,3 +1,10 @@
 """FereAI CLI — terminal interface for crypto trading and research."""
 
-__version__ = "0.1.0"
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Always report the installed distribution version.
+    __version__ = version("fere-cli")
+except PackageNotFoundError:
+    # Fallback for local/uninstalled source usage.
+    __version__ = "0.0.0"

fere_cli/async_util.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import asyncio
 import sys
 from functools import wraps
-from typing import Any, Callable
+from typing import Callable
 
 import click
 from fere_sdk import FereClient

fere_cli/banner.py

@@ -20,4 +20,5 @@ 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"
+    tagline = "crypto trading & research from your terminal"
+    return f"{LOGO}\n  v{__version__} — {tagline}\n"

fere_cli/commands/auth.py

@@ -1,12 +1,14 @@
-"""Auth commands: fere auth, fere whoami, fere credits."""
+"""Auth commands: fere auth, fere whoami, fere credits, fere claim-daily."""
 
 from __future__ import annotations
 
+import dataclasses
+
 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 ..async_util import async_command, get_client, is_tty
 from ..config import load_config, save_config
 from ..output import print_error, print_success
 
@@ -21,11 +23,7 @@ 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")
-    )
+    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")
@@ -68,18 +66,13 @@ async def auth(ctx, name: str | None):
 @click.pass_context
 @async_command
 async def whoami(ctx):
-    """Show current agent identity and wallet addresses."""
+    """Show current agent identity."""
     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)
+        print_success(user)
     except click.ClickException:
         raise
     except Exception as e:
@@ -106,3 +99,43 @@ async def credits(ctx):
     except Exception as e:
         print_error(str(e))
         raise SystemExit(1)
+
+
+@click.command(name="claim-daily")
+@click.pass_context
+@async_command
+async def claim_daily_credits(ctx):
+    """Claim your daily credits bonus."""
+    try:
+        client = await get_client(ctx)
+        result = await client.claim_daily_credits()
+        await client.close()
+
+        data = dataclasses.asdict(result)
+        if not result.success:
+            if result.error == "claim_cooldown":
+                msg = (
+                    "Already claimed today."
+                    f" Next claim available at {result.next_claim_available_at}"
+                    if result.next_claim_available_at
+                    else "Already claimed today."
+                )
+            elif result.error == "balance_too_high":
+                bal = result.current_balance
+                msg = (
+                    f"Balance too high to claim (current: {bal} credits)."
+                    if bal is not None
+                    else "Balance too high to claim."
+                )
+            elif result.error == "user_not_found":
+                msg = "User not found. Try logging in again."
+            else:
+                msg = result.error or "Daily claim failed."
+            print_error(msg, details=data)
+            raise SystemExit(1)
+        print_success(data)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        print_error(str(e))
+        raise SystemExit(1)

fere_cli/commands/chat.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import sys
 
 import click
 from rich.console import Console
@@ -14,7 +13,6 @@ from ..output import (
     print_error,
     print_streaming_text,
     print_success,
-    print_table_from_dicts,
 )
 
 console = Console()
@@ -61,20 +59,16 @@ async def chat(ctx, query, stream_mode, thread_id, agent_type):
         if query:
             # One-shot mode
             if stream_mode:
-                await _stream_chat(
-                    client, query, thread_id, agent_type
-                )
+                await _stream_chat(client, query, thread_id, agent_type)
             else:
-                await _oneshot_chat(
-                    client, query, thread_id, agent_type
-                )
+                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\""
+                'Usage: fere chat "your question"'
             )
     except click.ClickException:
         raise
@@ -89,9 +83,7 @@ async def chat(ctx, query, stream_mode, thread_id, agent_type):
 
 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
-    )
+    result = await client.chat(query, thread_id=thread_id, agent=agent_type)
     print_success(
         result,
         quiet_value=result.get("answer", ""),
@@ -121,9 +113,7 @@ async def _stream_chat(client, query, thread_id, agent_type):
                 text = event.data.get("text", "")
                 if text:
                     click.echo()  # newline after chunks
-                    console.print(
-                        f"\n[bold]Answer:[/bold] {text}"
-                    )
+                    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]"

fere_cli/commands/hooks.py

@@ -17,21 +17,23 @@ def hooks():
 
 
 @hooks.command()
-@click.option(
-    "--chain-id", required=True, type=int, help="Chain ID."
-)
-@click.option(
-    "--token", required=True, help="Token contract address."
-)
+@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_percentage": 0.3, "sell_percentage": 1.0}\').',
+    help=(
+        "Stop-loss config as JSON"
+        ' (e.g. \'{"price_percentage": 0.3, "sell_percentage": 1.0}\').'
+    ),
 )
 @click.option(
     "--take-profit",
     default=None,
-    help='Take-profit config as JSON (e.g. \'{"price_percentage": 1.0, "sell_percentage": 0.5}\').',
+    help=(
+        "Take-profit config as JSON"
+        ' (e.g. \'{"price_percentage": 1.0, "sell_percentage": 0.5}\').'
+    ),
 )
 @click.pass_context
 @async_command

fere_cli/commands/limit_order.py

@@ -28,9 +28,7 @@ def limit_order():
 @click.option(
     "--token-out", required=True, help="Destination token contract address."
 )
-@click.option(
-    "--amount", required=True, help="Amount in smallest unit."
-)
+@click.option("--amount", required=True, help="Amount in smallest unit.")
 @click.option(
     "--price",
     "price_usd_trigger",
@@ -52,7 +50,10 @@ def limit_order():
     "--condition",
     required=True,
     type=click.Choice(["gte", "lte"]),
-    help="Trigger condition: 'gte' (price >= target) or 'lte' (price <= target).",
+    help=(
+        "Trigger condition: 'gte' (price >= target)"
+        " or 'lte' (price <= target)."
+    ),
 )
 @click.option("--slippage-bps", default=50, type=int, help="Slippage (bps).")
 @click.option(

fere_cli/commands/utility.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import click
 import httpx
 
-from ..async_util import async_command, get_client, run_async
+from ..async_util import async_command, get_client
 from ..config import load_config, set_config_value
 from ..output import print_error, print_success
 

fere_cli/main.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import click
 
 from . import __version__
-from .commands.auth import auth, credits, whoami
+from .commands.auth import auth, claim_daily_credits, credits, whoami
 from .commands.chat import chat, threads
 from .commands.earn import earn
 from .commands.hooks import hooks
@@ -13,6 +13,7 @@ from .commands.limit_order import limit_order
 from .commands.portfolio import holdings, notifications, wallets
 from .commands.swap import swap
 from .commands.utility import chains, config, status
+from .update import maybe_check_for_updates
 
 
 @click.group(invoke_without_command=True)
@@ -53,6 +54,9 @@ def cli(ctx, output_json, quiet, agent, base_url):
     if base_url:
         ctx.obj["base_url_override"] = base_url
 
+    # Fetch runs in background; prompt fires on main thread after subcommand.
+    maybe_check_for_updates(output_json=output_json, quiet=quiet, ctx=ctx)
+
     # Show banner when no subcommand is given
     if ctx.invoked_subcommand is None and not output_json and not quiet:
         from rich.console import Console
@@ -68,6 +72,7 @@ def cli(ctx, output_json, quiet, agent, base_url):
 cli.add_command(auth)
 cli.add_command(whoami)
 cli.add_command(credits)
+cli.add_command(claim_daily_credits, name="claim-daily")
 
 # Chat
 cli.add_command(chat)

fere_cli/output.py

@@ -72,10 +72,21 @@ def print_json(data: Any) -> None:
 
 
 def print_dict(data: dict, title: str | None = None) -> None:
-    """Print a dict as a Rich panel with key-value pairs."""
+    """Print a dict as a Rich panel with key-value pairs.
+
+    None values are omitted from human output.
+    """
     lines = []
     for k, v in data.items():
-        if isinstance(v, (dict, list)):
+        if v is None:
+            continue
+        if isinstance(v, dict):
+            v = json_lib.dumps(
+                {k2: v2 for k2, v2 in v.items() if v2 is not None},
+                indent=2,
+                default=str,
+            )
+        elif isinstance(v, list):
             v = json_lib.dumps(v, indent=2, default=str)
         lines.append(f"[bold]{k}:[/bold] {v}")
     content = "\n".join(lines)

fere_cli/update.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Tuple
+
+if TYPE_CHECKING:
+    import click as _click
+
+import click
+
+from . import __version__
+
+PYPI_URL = "https://pypi.org/pypi/fere-cli/json"
+CHECK_INTERVAL_SECONDS = 86400  # once per day
+
+
+def _state_file() -> Path:
+    """Return path to the update-check state file."""
+    config_dir = Path.home() / ".config" / "fere-cli"
+    return config_dir / "update-check.json"
+
+
+def _should_check() -> bool:
+    """Return True if enough time has elapsed since last check."""
+    sf = _state_file()
+    if not sf.exists():
+        return True
+    try:
+        data = json.loads(sf.read_text())
+        last = data.get("last_check", 0)
+        return (time.time() - last) >= CHECK_INTERVAL_SECONDS
+    except Exception:
+        return True
+
+
+def _record_check() -> None:
+    """Persist current timestamp so we skip checks for a day."""
+    sf = _state_file()
+    try:
+        sf.parent.mkdir(parents=True, exist_ok=True)
+        sf.write_text(json.dumps({"last_check": time.time()}))
+    except Exception:
+        pass
+
+
+def _is_stable_version(version: str) -> bool:
+    """Return True if version is a pure X.Y.Z."""
+    parts = version.split(".")
+    if len(parts) != 3:
+        return False
+    try:
+        _ = (int(parts[0]), int(parts[1]), int(parts[2]))
+    except ValueError:
+        return False
+    return True
+
+
+def _is_prerelease(version: str) -> bool:
+    """Return True if version has a pre-release suffix."""
+    return not _is_stable_version(version)
+
+
+def _parse_version_tuple(
+    version: str,
+) -> Optional[Tuple[int, int, int]]:
+    """Parse the X.Y.Z prefix from a version string."""
+    base = version.split("a")[0].split("b")[0].split("rc")[0]
+    try:
+        major, minor, patch = base.split(".")
+        return int(major), int(minor), int(patch)
+    except Exception:
+        return None
+
+
+def _parse_prerelease_index(version: str) -> int:
+    """Return the numeric pre-release index (e.g. a2→2, rc1→1, stable→0).
+
+    Used as a tiebreaker so a2 sorts above a1 regardless of PyPI dict order.
+    Stable versions return 0 (they are ranked via the stability flag instead).
+    """
+    m = re.search(r"(?:a|b|rc)(\d+)$", version)
+    return int(m.group(1)) if m else 0
+
+
+def _fetch_pypi_releases(
+    timeout: float = 2.0,
+) -> Optional[dict]:
+    """Fetch release data from PyPI. Returns None on error."""
+    try:
+        req = urllib.request.Request(
+            PYPI_URL,
+            headers={"User-Agent": "fere-cli"},
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except (
+        urllib.error.URLError,
+        TimeoutError,
+        json.JSONDecodeError,
+        OSError,
+    ):
+        return None
+
+
+def _latest_from_releases(
+    releases: dict,
+    include_prerelease: bool = False,
+) -> Optional[str]:
+    """Pick the latest version from a PyPI releases dict."""
+    versions = list(releases.keys())
+    if not include_prerelease:
+        versions = [v for v in versions if _is_stable_version(v)]
+
+    parsed: list[Tuple[Tuple[int, int, int], int, int, str]] = []
+    for v in versions:
+        t = _parse_version_tuple(v)
+        if t is not None:
+            # stability: 1 for stable, 0 for pre-release (stable wins on tie)
+            # pre_idx: numeric pre-release index (a2 > a1 regardless of order)
+            stability = 1 if _is_stable_version(v) else 0
+            pre_idx = _parse_prerelease_index(v)
+            parsed.append((t, stability, pre_idx, v))
+
+    if not parsed:
+        return None
+
+    parsed.sort(key=lambda item: (item[0], item[1], item[2]))
+    return parsed[-1][3]
+
+
+def get_latest_stable_version(
+    timeout: float = 2.0,
+) -> Optional[str]:
+    """Fetch latest stable fere-cli version from PyPI."""
+    data = _fetch_pypi_releases(timeout)
+    if not data:
+        return None
+    return _latest_from_releases(
+        data.get("releases", {}),
+        include_prerelease=False,
+    )
+
+
+def get_latest_prerelease_version(
+    timeout: float = 2.0,
+) -> Optional[str]:
+    """Fetch latest fere-cli version (including pre-releases)."""
+    data = _fetch_pypi_releases(timeout)
+    if not data:
+        return None
+    return _latest_from_releases(
+        data.get("releases", {}),
+        include_prerelease=True,
+    )
+
+
+def is_newer_version(latest: str, current: str) -> bool:
+    """Return True if latest > current.
+
+    When X.Y.Z base is equal, stable > pre-release so that a user on
+    e.g. 0.2.0a1 is prompted to upgrade to the stable 0.2.0 release.
+    """
+    latest_t = _parse_version_tuple(latest)
+    current_t = _parse_version_tuple(current)
+    if latest_t is None or current_t is None:
+        return False
+    if latest_t != current_t:
+        return latest_t > current_t
+    # Same X.Y.Z base: stable release is newer than any pre-release.
+    return _is_stable_version(latest) and not _is_stable_version(current)
+
+
+def _perform_pipx_upgrade(pre: bool = False) -> bool:
+    pipx_path = shutil.which("pipx")
+    if not pipx_path:
+        return False
+    cmd = [pipx_path, "upgrade", "fere-cli"]
+    if pre:
+        cmd.append("--pip-args=--pre")
+    try:
+        subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def _perform_pip_upgrade(pre: bool = False) -> bool:
+    python = sys.executable or "python"
+    cmd = [python, "-m", "pip", "install", "--upgrade"]
+    if pre:
+        cmd.append("--pre")
+    cmd.append("fere-cli")
+    try:
+        subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def perform_self_upgrade(pre: bool = False) -> bool:
+    """Upgrade fere-cli via pipx (preferred) or pip."""
+    if _perform_pipx_upgrade(pre=pre):
+        return True
+    return _perform_pip_upgrade(pre=pre)
+
+
+def _do_prompt(current_is_pre: bool, latest: Optional[str]) -> None:
+    """Handle version comparison and interactive prompt on the main thread."""
+    if not latest:
+        _record_check()
+        return
+
+    if not is_newer_version(latest, __version__):
+        _record_check()
+        return
+
+    channel = "pre-release" if current_is_pre else "stable"
+    click.echo(
+        f"A new {channel} FereAI CLI version {latest} "
+        f"is available (you have {__version__})."
+    )
+
+    try:
+        should_upgrade = click.confirm(
+            "Do you want to upgrade now?",
+            default=False,
+            show_default=True,
+        )
+    except (click.Abort, EOFError):
+        _record_check()
+        return
+
+    if not should_upgrade:
+        _record_check()
+        return
+
+    click.echo(f"Upgrading fere-cli ({channel})...")
+    ok = perform_self_upgrade(pre=current_is_pre)
+    _record_check()
+    if ok:
+        # Omit flags intentionally — they may contain secrets.
+        subcmd = sys.argv[1] if len(sys.argv) > 1 else ""
+        rerun = f"fere {subcmd}" if subcmd else "fere"
+        click.echo(f"Upgrade completed. Please re-run: {rerun}")
+        # sys.exit(0) intentionally skips remaining call_on_close
+        # handlers — the process must restart after upgrade anyway.
+        sys.exit(0)
+    else:
+        click.echo(
+            "Upgrade failed. Manually upgrade with "
+            "'pipx upgrade fere-cli' or "
+            "'pip install --upgrade fere-cli'.",
+            err=True,
+        )
+
+
+def maybe_check_for_updates(
+    output_json: bool,
+    quiet: bool,
+    ctx: "Optional[_click.Context]" = None,
+) -> None:
+    """Check PyPI for newer CLI version, at most once per day.
+
+    The PyPI fetch runs in a background thread so it never blocks the
+    subcommand.  When *ctx* is provided the interactive prompt fires via
+    ``ctx.call_on_close()`` on the main thread after the subcommand
+    completes, avoiding any race with terminal I/O.  Without *ctx* the
+    check runs synchronously (useful for tests / direct calls).
+
+    - Skips non-interactive / piped usage.
+    - Skips when output_json or quiet is enabled.
+    - Skips when FERE_NO_UPDATE_CHECK=1 is set.
+    - When current version is a pre-release, checks for
+      the latest pre-release; otherwise checks stable only.
+    - Never raises; on any error it silently returns.
+    """
+    if output_json or quiet:
+        return
+
+    if os.environ.get("FERE_NO_UPDATE_CHECK") == "1":
+        return
+
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return
+
+    if not _should_check():
+        return
+
+    current_is_pre = _is_prerelease(__version__)
+    result: dict = {}
+    fetch_done = threading.Event()
+
+    def _bg_fetch() -> None:
+        try:
+            if current_is_pre:
+                result["latest"] = get_latest_prerelease_version()
+            else:
+                result["latest"] = get_latest_stable_version()
+        except Exception:
+            pass
+        finally:
+            fetch_done.set()
+
+    threading.Thread(target=_bg_fetch, daemon=True).start()
+
+    def _prompt() -> None:
+        # By the time the subcommand finishes the fetch is usually done;
+        # wait at most 2 s for any remaining network time.
+        fetch_done.wait(timeout=2.0)
+        _do_prompt(current_is_pre, result.get("latest"))
+
+    if ctx is not None:
+        ctx.call_on_close(_prompt)
+    else:
+        _prompt()

{fere_cli-0.2.0.dev17.dist-info → fere_cli-0.2.1.dev19.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fere-cli
-Version: 0.2.0.dev17
+Version: 0.2.1.dev19
 Summary: Terminal CLI for FereAI crypto trading and research
 Author-email: Fere AI <info@fere.ai>
 License-Expression: MIT
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1
-Requires-Dist: fere-sdk>=0.2.0.dev17
+Requires-Dist: fere-sdk>=0.2.1.dev19
 Requires-Dist: rich>=13.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'

fere_cli-0.2.1.dev19.dist-info/RECORD

@@ -0,0 +1,20 @@
+fere_cli/__init__.py,sha256=tQ7Vp1LCPsoI2hRFNekAZOEep_rO7TGuqhUqlm0ZMtU,341
+fere_cli/async_util.py,sha256=Ai832fD956lcDdYrTSbe59iU1Dl59rRZRODFz3KA9lU,1562
+fere_cli/banner.py,sha256=CE_sW4j460C3wGMwPVriZH-AJpWlGBHBxP1-h7DZUUM,823
+fere_cli/config.py,sha256=BIVr6ViLCWCEloWbxF0aekS4uSrvbUVzbSN1q9dHh_o,1574
+fere_cli/main.py,sha256=CDiWgb-4OPiVUakDq6wT6p5fYLGH3HKcdLcqfxGowTo,2510
+fere_cli/output.py,sha256=j_2iad_g_IqySnHf0Zqh9HD7H2q_DeUHv2OlNGhBcBM,3647
+fere_cli/update.py,sha256=vsdQTC_ue6xLpwvJGVmNt89XT64vfYV_S-vtumJEDiM,9731
+fere_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fere_cli/commands/auth.py,sha256=nQYY9Sx1e3p3p7ij4WggfCbj7YBV949dymfqe-pXRrw,3994
+fere_cli/commands/chat.py,sha256=YF_bI3HBY6vOrPMYjRrvPWP74kfqwIBIcAfb9ZI47_c,5106
+fere_cli/commands/earn.py,sha256=wDUmB7ZyQ4K2xGxm54WnnBFQiSZqThuC-h1J_yu4ito,3501
+fere_cli/commands/hooks.py,sha256=e3A1TD_qBt-I3zbQ_Wyf3oWhSceCQwFx0Wvn17Z74R4,2007
+fere_cli/commands/limit_order.py,sha256=Hv-9_erKUlyYE97IhSS9XOMJDrJy3qF7z-SA_ed7nzc,4188
+fere_cli/commands/portfolio.py,sha256=7JJOIolmlud6yWStw7iv9GCOH1igOilKUJzPr7ixx2g,1758
+fere_cli/commands/swap.py,sha256=v4urnENxLiwiGhSPTMDGEgRA0iglAC41xN_65h6xWw0,2507
+fere_cli/commands/utility.py,sha256=0icyDsouq-NchWg_CY2WdrH9VoQjg1WBybkkmZgknAg,2198
+fere_cli-0.2.1.dev19.dist-info/METADATA,sha256=sA1vjnn27fqqWPj1FR_jUGQpMvj7ESYKHIKkAHoVf7Y,3719
+fere_cli-0.2.1.dev19.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+fere_cli-0.2.1.dev19.dist-info/entry_points.txt,sha256=vOltZxMv_RJwS1AqO3UstqpRp74xPd4UMlf62Ma-fWM,43
+fere_cli-0.2.1.dev19.dist-info/RECORD,,

fere_cli-0.2.0.dev17.dist-info/RECORD

@@ -1,19 +0,0 @@
-fere_cli/__init__.py,sha256=8YO0NbqDOIoOAlhEvrTGibA7Iz-RK46OvnhAgPNlfMU,96
-fere_cli/async_util.py,sha256=1HFLWIyWfL30Qkz_QcWAb2EVaQ1jysCzxCbCqBjAPGc,1567
-fere_cli/banner.py,sha256=56sSuANPj_DuUgn6sG15Y0MM6wOoqFrYydqIl4svWwQ,797
-fere_cli/config.py,sha256=BIVr6ViLCWCEloWbxF0aekS4uSrvbUVzbSN1q9dHh_o,1574
-fere_cli/main.py,sha256=9zxTaYRvwm04AXnK3_vFDE4EOy-txnFgXCqVe-itAwQ,2234
-fere_cli/output.py,sha256=Q3Uo34huTasjqKnhbX92CtfQrquDDjM2UGaPTD5Atos,3356
-fere_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fere_cli/commands/auth.py,sha256=rdu3v7ARk9p56djEyI41ECzObWUOUHLCE0bB-d-Kz3Y,2763
-fere_cli/commands/chat.py,sha256=kLxLnXzpxnGZSJ9vhMtZo3LABL9PdQzQ-r5lVos3k3E,5283
-fere_cli/commands/earn.py,sha256=wDUmB7ZyQ4K2xGxm54WnnBFQiSZqThuC-h1J_yu4ito,3501
-fere_cli/commands/hooks.py,sha256=oVSeI7jpYUSygqG8pqU9grtltZ7f_GRma5Z5JGlLGvE,1965
-fere_cli/commands/limit_order.py,sha256=5d4F669K-fW4iNeZA44y5L7WQLMXqughJlwS51tUmwY,4167
-fere_cli/commands/portfolio.py,sha256=7JJOIolmlud6yWStw7iv9GCOH1igOilKUJzPr7ixx2g,1758
-fere_cli/commands/swap.py,sha256=v4urnENxLiwiGhSPTMDGEgRA0iglAC41xN_65h6xWw0,2507
-fere_cli/commands/utility.py,sha256=8ofNJwxAYSBHjmX6VPIANUEPQkPXtVjIJYkK5UWXZJ4,2209
-fere_cli-0.2.0.dev17.dist-info/METADATA,sha256=33hk4SpMmdYpe849Z7KBPkHE9OTe-ihtAjRkp1jSD2Q,3719
-fere_cli-0.2.0.dev17.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-fere_cli-0.2.0.dev17.dist-info/entry_points.txt,sha256=vOltZxMv_RJwS1AqO3UstqpRp74xPd4UMlf62Ma-fWM,43
-fere_cli-0.2.0.dev17.dist-info/RECORD,,