fere-cli 0.2.0.dev15__tar.gz → 0.2.1.dev19__tar.gz

{fere_cli-0.2.0.dev15 → fere_cli-0.2.1.dev19}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fere-cli
-Version: 0.2.0.dev15
+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.dev15
+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.0.dev15 → fere_cli-0.2.1.dev19}/install.sh

@@ -35,8 +35,8 @@ case "$TARGET" in
         ;;
 esac
 
-# Colors (disabled if not a TTY)
-if [ -t 1 ]; then
+# Colors (disabled if not a suitable TTY or when piped)
+if [ -t 1 ] && [ -t 0 ] && [ "${TERM:-}" != "dumb" ] && [ -z "${NO_COLOR:-}" ] && [ -z "${FERE_NO_COLOR:-}" ]; then
     RED='\033[0;31m'
     GREEN='\033[0;32m'
     YELLOW='\033[0;33m'
@@ -130,9 +130,9 @@ install_with_pipx() {
     if command -v pipx >/dev/null 2>&1; then
         info "Installing with pipx..."
         if [ -n "$PIPX_EXTRA_ARGS" ]; then
-            pipx install --force "$PIPX_EXTRA_ARGS" "$PKG_SPEC" || return 1
+            pipx install --python "$PYTHON" --force "$PIPX_EXTRA_ARGS" "$PKG_SPEC" || return 1
         else
-            pipx install --force "$PKG_SPEC" || return 1
+            pipx install --python "$PYTHON" --force "$PKG_SPEC" || return 1
         fi
         return 0
     fi
@@ -187,6 +187,69 @@ detect_user_bin() {
     return 1
 }
 
+expand_path() {
+    local path="$1"
+    case "$path" in
+        "~")
+            printf "%s\n" "${HOME:-}"
+            ;;
+        "~/"*)
+            printf "%s\n" "${HOME:-}/${path#~/}"
+            ;;
+        *)
+            printf "%s\n" "$path"
+            ;;
+    esac
+}
+
+append_path_export_if_missing() {
+    local rc_file="$1"
+    local user_bin="$2"
+    local rc_path rc_dir
+
+    [ -n "$rc_file" ] || return 1
+    [ -n "$user_bin" ] || return 1
+
+    rc_path=$(expand_path "$rc_file")
+    [ -n "$rc_path" ] || return 1
+
+    rc_dir=$(dirname "$rc_path")
+    if [ ! -d "$rc_dir" ]; then
+        mkdir -p "$rc_dir" 2>/dev/null || return 1
+    fi
+
+    touch "$rc_path" 2>/dev/null || return 1
+
+    if grep -v "^[[:space:]]*#" "$rc_path" 2>/dev/null | grep -qE "(^|:|=\"|=)${user_bin}(:|\"|\\\$|$)"; then
+        return 0
+    fi
+    # Also catch $HOME-relative variants (e.g. $HOME/.local/bin or ${HOME}/.local/bin)
+    # to avoid duplicates when the user already has an equivalent entry.
+    home_rel="${user_bin#"${HOME:-}"}"
+    if [ "$home_rel" != "$user_bin" ]; then
+        if grep -v "^[[:space:]]*#" "$rc_path" 2>/dev/null | grep -qE "(^|:|=\"|=)\\\$HOME${home_rel}(:|\"|\\\$|$)"; then
+            return 0
+        fi
+        if grep -v "^[[:space:]]*#" "$rc_path" 2>/dev/null | grep -qE "(^|:|=\"|=)\\\$\{HOME\}${home_rel}(:|\"|\\\$|$)"; then
+            return 0
+        fi
+    fi
+
+    {
+        echo ""
+        echo "# Added by FereAI CLI installer"
+        # Write $HOME-relative path when possible so the entry stays valid
+        # even if the home directory path changes (e.g. LDAP migration).
+        if [ "$home_rel" != "$user_bin" ]; then
+            echo "export PATH=\"\$HOME${home_rel}:\$PATH\""
+        else
+            echo "export PATH=\"$user_bin:\$PATH\""
+        fi
+    } >>"$rc_path" 2>/dev/null || return 1
+
+    return 0
+}
+
 detect_shell_rc() {
     local shell_path
     shell_path="${SHELL:-}"
@@ -258,11 +321,17 @@ else
                 echo "This takes effect immediately in all fish sessions."
                 ;;
             *)
-                echo "To fix this, add the following line to $rc_file:"
-                echo ""
-                echo "  export PATH=\"$user_bin:\$PATH\""
-                echo ""
-                echo "Then restart your terminal or reload your shell (e.g. 'source $rc_file')."
+                if append_path_export_if_missing "$rc_file" "$user_bin"; then
+                    success "Updated your PATH in $rc_file to include '$user_bin'."
+                    echo ""
+                    info "Please restart your terminal so 'fere' is available in new shells."
+                else
+                    echo "To fix this, add the following line to $rc_file:"
+                    echo ""
+                    echo "  export PATH=\"$user_bin:\$PATH\""
+                    echo ""
+                    echo "After updating, restart your terminal so 'fere' is available."
+                fi
                 ;;
         esac
     else

{fere_cli-0.2.0.dev15 → fere_cli-0.2.1.dev19}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "fere-cli"
-version = "0.2.0.dev15"
+version = "0.2.1.dev19"
 description = "Terminal CLI for FereAI crypto trading and research"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 authors = [{ name = "Fere AI", email = "info@fere.ai" }]
 dependencies = [
-    "fere-sdk>=0.2.0.dev15",
+    "fere-sdk>=0.2.1.dev19",
     "click>=8.1",
     "rich>=13.0",
 ]

fere_cli-0.2.1.dev19/src/fere_cli/__init__.py

@@ -0,0 +1,10 @@
+"""FereAI CLI — terminal interface for crypto trading and research."""
+
+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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.0.dev15 → fere_cli-0.2.1.dev19}/src/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-0.2.1.dev19/src/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.dev15 → fere_cli-0.2.1.dev19}/tests/test_install_sh.py

@@ -102,8 +102,35 @@ def test_install_prints_path_guidance_when_fere_missing(tmp_path: Path) -> None:
     fake_brew = bin_dir / "brew"
     _make_executable(fake_brew, "#!/bin/sh\nexit 1\n")
 
+    # Symlink essential system utilities so the shell script can run, but
+    # exclude python/pipx/pip/fere (those are controlled by fakes above).
+    exclude = {
+        "python",
+        "python3",
+        "python3.11",
+        "python3.12",
+        "python3.13",
+        "pip",
+        "pip3",
+        "pipx",
+        "fere",
+    }
+    for sysdir in ["/usr/bin", "/bin"]:
+        p = Path(sysdir)
+        if p.is_dir():
+            for entry in p.iterdir():
+                if (
+                    entry.name not in exclude
+                    and not entry.name.startswith("python")
+                    and not (bin_dir / entry.name).exists()
+                ):
+                    try:
+                        (bin_dir / entry.name).symlink_to(entry)
+                    except OSError:
+                        pass
+
     env = os.environ.copy()
-    env["PATH"] = f"{bin_dir}{os.pathsep}{env.get('PATH', '')}"
+    env["PATH"] = str(bin_dir)  # isolated — real fere must not be found
     env["HOME"] = str(home_dir)
     env["SHELL"] = "/bin/bash"
 
@@ -118,12 +145,13 @@ def test_install_prints_path_guidance_when_fere_missing(tmp_path: Path) -> None:
     # Installer exits 0 (install succeeded) but warns fere isn't on PATH
     assert result.returncode == 0
     assert "Installation complete, but 'fere' is not in PATH." in out
-    # Verify specific PATH guidance (not the generic fallback)
-    assert "export PATH=" in out
+    # Verify the rc file was updated with PATH guidance
     expected_rc = (
         ".bash_profile" if platform.system() == "Darwin" else ".bashrc"
     )
     assert expected_rc in out
+    # Either the script auto-updated the rc file or printed manual guidance
+    assert "Updated your PATH" in out or "export PATH=" in out
 
 
 def test_invalid_version_argument(tmp_path: Path) -> None:

fere_cli-0.2.1.dev19/tests/test_update.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import json
+import types
+
+import fere_cli.update as update
+
+
+def test_is_stable_version_accepts_pure_semver() -> None:
+    assert update._is_stable_version("0.1.0")
+    assert update._is_stable_version("10.20.30")
+
+
+def test_is_stable_version_rejects_prereleases() -> None:
+    assert not update._is_stable_version("0.1.0a1")
+    assert not update._is_stable_version("0.1.0rc1")
+    assert not update._is_stable_version("1.2")
+    assert not update._is_stable_version("1.2.3.4")
+    assert not update._is_stable_version("foo")
+
+
+def test_is_prerelease() -> None:
+    assert update._is_prerelease("0.2.0a1")
+    assert update._is_prerelease("0.2.0rc1")
+    assert not update._is_prerelease("0.2.0")
+
+
+def test_is_newer_version_compares_semver() -> None:
+    assert update.is_newer_version("0.2.0", "0.1.0")
+    assert update.is_newer_version("1.0.0", "0.9.9")
+    assert not update.is_newer_version("0.1.0", "0.1.0")
+    assert not update.is_newer_version("0.1.0", "0.2.0")
+
+
+def test_is_newer_version_prerelease_prefix() -> None:
+    assert update.is_newer_version("0.3.0a1", "0.2.0")
+    assert not update.is_newer_version("0.2.0a1", "0.2.0")
+    # stable is newer than same-base pre-release
+    assert update.is_newer_version("0.2.0", "0.2.0a1")
+
+
+def _make_fake_urlopen(releases: dict):
+    class FakeResponse:
+        def __init__(self, payload: bytes) -> None:
+            self._payload = payload
+
+        def read(self) -> bytes:
+            return self._payload
+
+        def __enter__(self) -> "FakeResponse":
+            return self
+
+        def __exit__(self, *exc: object) -> None:
+            return None
+
+    def fake_urlopen(req, timeout=0):
+        payload = {"releases": releases}
+        return FakeResponse(json.dumps(payload).encode("utf-8"))
+
+    return fake_urlopen
+
+
+def test_get_latest_stable_version_ignores_prereleases(
+    monkeypatch,
+) -> None:
+    releases = {
+        "0.1.0": [],
+        "0.2.0a1": [],
+        "0.2.0": [],
+    }
+    monkeypatch.setattr(
+        update.urllib.request,
+        "urlopen",
+        _make_fake_urlopen(releases),
+    )
+    latest = update.get_latest_stable_version()
+    assert latest == "0.2.0"
+
+
+def test_get_latest_prerelease_version_includes_all(
+    monkeypatch,
+) -> None:
+    releases = {
+        "0.1.0": [],
+        "0.2.0a1": [],
+        "0.2.0": [],
+        "0.3.0a1": [],
+    }
+    monkeypatch.setattr(
+        update.urllib.request,
+        "urlopen",
+        _make_fake_urlopen(releases),
+    )
+    latest = update.get_latest_prerelease_version()
+    assert latest == "0.3.0a1"
+
+
+def test_latest_from_releases_prerelease_index_ordering() -> None:
+    """a2 must beat a1 regardless of PyPI dict insertion order."""
+    releases_a1_first = {"0.2.0a1": [], "0.2.0a2": []}
+    releases_a2_first = {"0.2.0a2": [], "0.2.0a1": []}
+    assert (
+        update._latest_from_releases(releases_a1_first, include_prerelease=True)
+        == "0.2.0a2"
+    )
+    assert (
+        update._latest_from_releases(releases_a2_first, include_prerelease=True)
+        == "0.2.0a2"
+    )
+
+
+def test_should_check_respects_interval(monkeypatch, tmp_path) -> None:
+    sf = tmp_path / "update-check.json"
+    monkeypatch.setattr(update, "_state_file", lambda: sf)
+
+    # No file → should check
+    assert update._should_check()
+
+    # Just checked → skip
+    update._record_check()
+    assert not update._should_check()
+
+    # Old timestamp → should check
+    import time
+
+    sf.write_text(json.dumps({"last_check": time.time() - 100_000}))
+    assert update._should_check()
+
+
+def test_maybe_check_skips_when_env_var_set_with_tty(
+    monkeypatch, capsys
+) -> None:
+    """FERE_NO_UPDATE_CHECK=1 suppresses check even when TTY is active."""
+    fake_tty = types.SimpleNamespace(isatty=lambda: True)
+    monkeypatch.setattr(update.sys, "stdin", fake_tty)
+    monkeypatch.setattr(update.sys, "stdout", fake_tty)
+    monkeypatch.setenv("FERE_NO_UPDATE_CHECK", "1")
+    monkeypatch.setattr(update, "_should_check", lambda: True)
+    monkeypatch.setattr(
+        update, "get_latest_stable_version", lambda **kw: "999.0.0"
+    )
+    monkeypatch.setattr(
+        update, "is_newer_version", lambda latest, current: True
+    )
+
+    update.maybe_check_for_updates(output_json=False, quiet=False)
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert captured.err == ""
+
+
+def test_maybe_check_skips_non_tty(monkeypatch, capsys) -> None:
+    """Non-TTY stdin/stdout suppresses check regardless of env var."""
+    fake_non_tty = types.SimpleNamespace(isatty=lambda: False)
+    monkeypatch.setattr(update.sys, "stdin", fake_non_tty)
+    monkeypatch.setattr(update.sys, "stdout", fake_non_tty)
+    monkeypatch.delenv("FERE_NO_UPDATE_CHECK", raising=False)
+    monkeypatch.setattr(update, "_should_check", lambda: True)
+    monkeypatch.setattr(
+        update, "get_latest_stable_version", lambda **kw: "999.0.0"
+    )
+    monkeypatch.setattr(
+        update, "is_newer_version", lambda latest, current: True
+    )
+
+    update.maybe_check_for_updates(output_json=False, quiet=False)
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert captured.err == ""
+
+
+def _setup_tty_with_update(monkeypatch, tmp_path):
+    """Common setup: fake TTY, update available, state file in tmp_path."""
+    import io
+
+    sf = tmp_path / "update-check.json"
+    monkeypatch.setattr(update, "_state_file", lambda: sf)
+    # stdin only needs isatty(); stdout must also be writable for click.echo.
+    fake_stdin = types.SimpleNamespace(isatty=lambda: True)
+
+    class FakeTTYOut(io.StringIO):
+        def isatty(self) -> bool:
+            return True
+
+    monkeypatch.setattr(update.sys, "stdin", fake_stdin)
+    monkeypatch.setattr(update.sys, "stdout", FakeTTYOut())
+    monkeypatch.delenv("FERE_NO_UPDATE_CHECK", raising=False)
+    monkeypatch.setattr(update, "_should_check", lambda: True)
+    monkeypatch.setattr(
+        update, "get_latest_stable_version", lambda **kw: "999.0.0"
+    )
+    return sf
+
+
+def test_maybe_check_user_declines_records_check(monkeypatch, tmp_path) -> None:
+    """User declines upgrade → _record_check() persists timestamp."""
+    sf = _setup_tty_with_update(monkeypatch, tmp_path)
+    monkeypatch.setattr(update.click, "confirm", lambda *a, **kw: False)
+
+    update.maybe_check_for_updates(output_json=False, quiet=False)
+
+    assert sf.exists(), "_record_check() must write state file on decline"
+
+
+def test_maybe_check_user_confirms_upgrades_and_exits(
+    monkeypatch, tmp_path
+) -> None:
+    """User confirms upgrade → sys.exit(0) and state file written."""
+    import pytest
+
+    sf = _setup_tty_with_update(monkeypatch, tmp_path)
+    monkeypatch.setattr(update.click, "confirm", lambda *a, **kw: True)
+    monkeypatch.setattr(update, "perform_self_upgrade", lambda **kw: True)
+
+    with pytest.raises(SystemExit) as exc_info:
+        update.maybe_check_for_updates(output_json=False, quiet=False)
+
+    assert exc_info.value.code == 0
+    assert sf.exists(), "_record_check() must write state file on upgrade"

fere_cli-0.2.0.dev15/src/fere_cli/__init__.py

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