systemr-cli 1.0.0__py3-none-any.whl

neo/__init__.py

@@ -0,0 +1,3 @@
+"""System R CLI — trading operating system in your terminal."""
+
+__version__ = "1.0.0"

neo/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m neo`."""
+
+from neo.cli import cli
+
+cli()

neo/auth.py

@@ -0,0 +1,192 @@
+"""Authentication manager — login, logout, token storage."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+
+import httpx
+
+from neo.config import AUTH_FILE, ensure_neo_home, get_api_url
+
+
+@dataclass
+class AuthToken:
+    access_token: str
+    refresh_token: str | None
+    email: str
+    expires_at: float  # Unix timestamp
+
+    def is_expired(self) -> bool:
+        return time.time() >= self.expires_at
+
+    def to_dict(self) -> dict:
+        return {
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+            "email": self.email,
+            "expires_at": self.expires_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> AuthToken:
+        return cls(
+            access_token=data["access_token"],
+            refresh_token=data.get("refresh_token"),
+            email=data["email"],
+            expires_at=data.get("expires_at", 0),
+        )
+
+
+class AuthManager:
+    """Handles login, logout, and token persistence."""
+
+    def __init__(self) -> None:
+        self._token: AuthToken | None = None
+
+    def load(self) -> AuthToken | None:
+        """Load stored token from disk."""
+        if self._token is not None:
+            return self._token
+        if not AUTH_FILE.exists():
+            return None
+        try:
+            data = json.loads(AUTH_FILE.read_text())
+            self._token = AuthToken.from_dict(data)
+            return self._token
+        except (json.JSONDecodeError, KeyError):
+            return None
+
+    def save(self, token: AuthToken) -> None:
+        """Persist token to disk with secure permissions."""
+        ensure_neo_home()
+        AUTH_FILE.write_text(json.dumps(token.to_dict(), indent=2))
+        os.chmod(AUTH_FILE, 0o600)
+        self._token = token
+
+    def clear(self) -> None:
+        """Remove stored credentials and attempt server-side revocation.
+
+        Calls the logout endpoint to invalidate the token server-side.
+        The local file is always deleted regardless of revocation success.
+        """
+        token = self.load()
+        if token and token.access_token:
+            self._try_revoke(token)
+        if AUTH_FILE.exists():
+            AUTH_FILE.unlink()
+        self._token = None
+
+    def _try_revoke(self, token: AuthToken) -> None:
+        """Attempt to revoke the token server-side.
+
+        Best-effort — silent on failure. The local clear always happens.
+
+        Args:
+            token: The token to revoke.
+        """
+        api_url = get_api_url()
+        try:
+            httpx.post(
+                f"{api_url}/api/auth/logout",
+                headers={"Authorization": f"Bearer {token.access_token}"},
+                timeout=5.0,
+            )
+        except Exception:
+            pass
+
+    def get_token(self) -> AuthToken | None:
+        """Get current token, returning None if expired."""
+        token = self.load()
+        if token is None:
+            return None
+        if token.is_expired():
+            refreshed = self._try_refresh(token)
+            if refreshed:
+                self.save(refreshed)
+                return refreshed
+            self.clear()
+            return None
+        return token
+
+    async def register(self, email: str, password: str, name: str = "") -> AuthToken:
+        """Register a new account and auto-login.
+
+        Args:
+            email: User's email address.
+            password: Chosen password.
+            name: Optional display name.
+
+        Returns:
+            AuthToken for the new account.
+
+        Raises:
+            httpx.HTTPStatusError: If registration fails (e.g., email taken).
+        """
+        api_url = get_api_url()
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                f"{api_url}/api/auth/register",
+                json={"email": email, "password": password, "name": name},
+                timeout=30.0,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+        token = AuthToken(
+            access_token=data.get("access_token") or data.get("session_token", ""),
+            refresh_token=data.get("refresh_token"),
+            email=email,
+            expires_at=time.time() + data.get("expires_in", 86400),
+        )
+        self.save(token)
+        return token
+
+    async def login(self, email: str, password: str) -> AuthToken:
+        """Authenticate against System R API and store the token."""
+        api_url = get_api_url()
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                f"{api_url}/api/auth/login",
+                json={"email": email, "password": password},
+                timeout=30.0,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+        token = AuthToken(
+            access_token=data.get("access_token") or data.get("session_token", ""),
+            refresh_token=data.get("refresh_token"),
+            email=email,
+            expires_at=time.time() + data.get("expires_in", 86400),
+        )
+        self.save(token)
+        return token
+
+    def _try_refresh(self, token: AuthToken) -> AuthToken | None:
+        """Synchronously attempt to refresh an expired token."""
+        if not token.refresh_token:
+            return None
+        api_url = get_api_url()
+        try:
+            resp = httpx.post(
+                f"{api_url}/api/auth/refresh",
+                json={"refresh_token": token.refresh_token},
+                timeout=15.0,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            return AuthToken(
+                access_token=data["access_token"],
+                refresh_token=data.get("refresh_token", token.refresh_token),
+                email=token.email,
+                expires_at=time.time() + data.get("expires_in", 3600),
+            )
+        except httpx.HTTPError:
+            return None
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self.get_token() is not None

neo/cli.py

@@ -0,0 +1,205 @@
+"""System R CLI — main entry point.
+
+Shows the home screen when invoked without subcommands.
+Initializes the local directory structure on first run.
+Checks for updates on launch (non-blocking).
+"""
+
+from __future__ import annotations
+
+import click
+
+from neo import __version__
+from neo.commands.auth_commands import balance, link_wallet, login, logout, pay, register, verify, whoami
+from neo.commands.chat_commands import chat
+from neo.commands.cron_commands import cron
+from neo.commands.doctor_command import doctor
+from neo.commands.eval_commands import eval
+from neo.commands.journal_commands import journal
+from neo.commands.plan_commands import plan
+from neo.commands.risk_commands import risk
+from neo.commands.scan_commands import scan
+from neo.commands.size_commands import size
+from neo.display.theme import (
+    WHITE,
+    GRAY,
+    DIM,
+    MUTED,
+    GREEN,
+    RED,
+    ICON_CONNECTED,
+    ICON_DISCONNECTED,
+    console,
+    print_banner,
+    print_separator,
+)
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="systemr")
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """System R — trading operating system in your terminal."""
+    # Configure logging (suppress INFO from terminal, only WARN+ to stderr)
+    from neo.logging import configure_logging
+    configure_logging(debug=False)
+
+    # Initialize local directory on first run
+    from neo.profile import init_all
+    init_all()
+
+    # Load saved permission profile
+    from neo.confirmation import load_profile_from_config
+    load_profile_from_config()
+
+    if ctx.invoked_subcommand is None:
+        _show_home()
+
+
+def _show_home() -> None:
+    """Home screen — clean, three-state status display."""
+    from neo.auth import AuthManager
+    from neo.profile import profile_exists
+
+    print_banner()
+
+    auth = AuthManager()
+    token = auth.get_token()
+
+    if not token:
+        # State 1: Not logged in
+        console.print(
+            f"  [{RED}]{ICON_DISCONNECTED}[/] [{RED}]not connected[/]   "
+            f"[{MUTED}]run[/] [{DIM}]systemr login[/]"
+        )
+    else:
+        # State 2 or 3: Logged in
+        console.print(
+            f"  [{GREEN}]{ICON_CONNECTED}[/] [{GREEN}]connected[/] [{GRAY}]as {token.email}[/]"
+        )
+        if not profile_exists():
+            # State 2: No profile yet
+            console.print(
+                f"  [{GRAY}]{ICON_DISCONNECTED}[/] [{GRAY}]no profile yet[/]   "
+                f"[{MUTED}]run[/] [{DIM}]systemr setup[/]"
+            )
+
+    console.print()
+
+
+# ── Command registration ────────────────────────────────────────────
+
+# Auth & Billing
+cli.add_command(register)
+cli.add_command(login)
+cli.add_command(verify)
+cli.add_command(pay)
+cli.add_command(balance)
+cli.add_command(link_wallet)
+cli.add_command(logout)
+cli.add_command(whoami)
+
+# Trading commands
+cli.add_command(size)
+cli.add_command(risk)
+cli.add_command(eval)
+cli.add_command(scan)
+cli.add_command(plan)
+
+# Local
+cli.add_command(journal)
+
+# Interactive
+cli.add_command(chat)
+
+# Automation
+cli.add_command(cron)
+
+# Diagnostics
+cli.add_command(doctor)
+
+
+# Setup
+@click.command()
+def setup() -> None:
+    """Run the profile setup wizard."""
+    from neo.display.theme import print_success, print_info
+    from neo.profile import (
+        profile_exists, save_profile, save_rules, save_standing_order, init_all,
+    )
+
+    init_all()
+    print_banner()
+
+    if profile_exists():
+        print_info("Profile already exists. Answers will overwrite it.")
+
+    console.print(f"  [{WHITE}]Welcome. Let's set up your profile.[/]")
+    console.print()
+
+    style = click.prompt(click.style("  Trading style", fg="white"))
+    timeframe = click.prompt(click.style("  Timeframe", fg="white"))
+    risk_pct = click.prompt(click.style("  Max risk per trade (%)", fg="white"))
+    daily_loss = click.prompt(click.style("  Max daily loss (%)", fg="white"))
+    max_pos = click.prompt(click.style("  Max open positions", fg="white"), type=int)
+    broker = click.prompt(click.style("  Primary broker", fg="white"))
+    name = click.prompt(click.style("  Your name", fg="white"))
+
+    console.print()
+    console.print(f"  [{GRAY}]Any hard rules? (comma-separated, or Enter to skip)[/]")
+    rules_input = click.prompt(
+        click.style("  Rules", fg="white"), default="", show_default=False,
+    )
+    hard_rules = [r.strip() for r in rules_input.split(",") if r.strip()]
+
+    experience = click.prompt(
+        click.style("  Experience level", fg="white"),
+        type=click.Choice(["beginner", "intermediate", "advanced"]),
+    )
+
+    console.print()
+    print_separator()
+    console.print()
+
+    save_profile(
+        name=name, style=style, timeframe=timeframe,
+        experience=experience, risk_pct=risk_pct,
+        daily_loss_pct=daily_loss, max_positions=max_pos, broker=broker,
+    )
+    print_success("Profile saved to ~/.systemr/PROFILE.md")
+
+    if hard_rules:
+        save_rules(hard_rules=hard_rules, soft_rules=[])
+        print_success("Rules saved to ~/.systemr/RULES.md")
+
+    # Standing orders (optional)
+    console.print()
+    console.print(f"  [{GRAY}]Standing orders give your agent authority to act within boundaries.[/]")
+    console.print(f"  [{DIM}]Example: 'Every morning, scan watchlist for setups. Report only, no trades.'[/]")
+    add_orders = click.confirm(
+        click.style("  Add a standing order?", fg="white"), default=False,
+    )
+    if add_orders:
+        order_name = click.prompt(click.style("  Order name", fg="white"))
+        order_action = click.prompt(click.style("  What should it do?", fg="white"))
+        order_trigger = click.prompt(
+            click.style("  When? (e.g., 'Daily at 7AM', 'On trade close')", fg="white"),
+        )
+        save_standing_order(
+            name=order_name,
+            scope=order_action,
+            trigger=order_trigger,
+            approval="Report only — do NOT execute trades without confirmation",
+            escalation="Alert if unable to complete",
+            action=order_action,
+        )
+        print_success(f"Standing order '{order_name}' saved to RULES.md")
+
+    console.print()
+    console.print(
+        f"  [{WHITE}]You're ready. Run `systemr chat` to start.[/]"
+    )
+    console.print()
+
+
+cli.add_command(setup)

neo/client.py

@@ -0,0 +1,64 @@
+"""NeoClient — async HTTP client with session auth and auto-refresh."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from neo.auth import AuthManager
+from neo.config import get_api_url
+
+
+class NeoClient:
+    """Authenticated async HTTP client for System R API."""
+
+    def __init__(self, auth: AuthManager) -> None:
+        self._auth = auth
+        self._base_url = get_api_url()
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict | None = None,
+        params: dict | None = None,
+        timeout: float = 30.0,
+    ) -> dict[str, Any]:
+        """Make an authenticated API request. Retries once on 401."""
+        headers = self._auth_headers()
+        async with httpx.AsyncClient(base_url=self._base_url) as client:
+            resp = await client.request(
+                method, path, json=json, params=params, headers=headers, timeout=timeout,
+            )
+            # Auto-refresh on 401
+            if resp.status_code == 401:
+                token = self._auth.get_token()
+                if token is None:
+                    raise AuthRequired()
+                headers = self._auth_headers()
+                resp = await client.request(
+                    method, path, json=json, params=params, headers=headers, timeout=timeout,
+                )
+            resp.raise_for_status()
+            return resp.json()
+
+    async def get(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        return await self.request("GET", path, **kwargs)
+
+    async def post(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        return await self.request("POST", path, **kwargs)
+
+    def _auth_headers(self) -> dict[str, str]:
+        token = self._auth.get_token()
+        if token is None:
+            raise AuthRequired()
+        return {"Authorization": f"Bearer {token.access_token}"}
+
+
+class AuthRequired(Exception):
+    """Raised when a request requires auth but no valid token exists."""
+
+    def __init__(self) -> None:
+        super().__init__("Not authenticated. Run `systemr login` first.")