systemr-cli 1.0.0__py3-none-any.whl

neo/commands/plan_commands.py

@@ -0,0 +1,77 @@
+"""Plan command — neo plan (trade plan generation)."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from neo.auth import AuthManager
+from neo.client import AuthRequired, NeoClient
+from neo.display.formatters import fmt_price, fmt_pct, fmt_risk, fmt_qty
+from neo.display.tables import kv_table
+from neo.display.theme import console, print_error, GREEN
+
+
+@click.command()
+@click.option("--ticker", required=True, help="Ticker symbol")
+@click.option("--equity", required=True, type=float, help="Account equity ($)")
+@click.option("--risk-pct", type=float, default=1.0, help="Risk per trade (%, default 1.0)")
+@click.option("--direction", type=click.Choice(["long", "short"]), default=None, help="Force direction (auto-detect if omitted)")
+def plan(ticker: str, equity: float, risk_pct: float, direction: str | None) -> None:
+    """Generate a complete trade plan for a ticker."""
+    auth = AuthManager()
+    client = NeoClient(auth)
+
+    payload: dict = {
+        "ticker": ticker.upper(),
+        "equity": equity,
+        "risk_percent": risk_pct,
+    }
+    if direction:
+        payload["direction"] = direction
+
+    try:
+        with console.status(f"[neo.green]Building plan for {ticker.upper()}...[/]"):
+            result = asyncio.run(client.post("/api/plans", json=payload))
+    except AuthRequired:
+        print_error("Not authenticated. Run `neo login` first.")
+        raise SystemExit(1)
+    except Exception as e:
+        print_error(f"Plan generation failed: {e}")
+        raise SystemExit(1)
+
+    # Display the plan
+    data: dict[str, str] = {"Ticker": ticker.upper()}
+
+    dir_val = result.get("direction", direction or "—")
+    dir_style = f"bold {GREEN}" if dir_val == "long" else "bold red"
+    data["Direction"] = f"[{dir_style}]{dir_val.upper()}[/]"
+
+    if "entry" in result:
+        data["Entry"] = fmt_price(result["entry"])
+    if "stop" in result:
+        data["Stop"] = fmt_price(result["stop"])
+    if "target" in result:
+        data["Target"] = fmt_price(result["target"])
+    if "risk_per_share" in result:
+        data["Risk/Share"] = fmt_price(result["risk_per_share"])
+    if "risk_amount" in result:
+        data["Risk Amount"] = fmt_risk(result["risk_amount"])
+    if "shares" in result:
+        data["Shares"] = fmt_qty(result["shares"])
+    if "position_value" in result:
+        data["Position Value"] = fmt_price(result["position_value"])
+    if "reward_risk" in result:
+        data["Reward:Risk"] = f"{result['reward_risk']:.2f}"
+    if "confidence" in result:
+        data["Confidence"] = fmt_pct(result["confidence"])
+
+    kv_table(f"TRADE PLAN — {ticker.upper()}", data)
+
+    # Show rationale if provided
+    if "rationale" in result:
+        console.print(f"\n[bold]Rationale:[/] {result['rationale']}")
+    if "notes" in result:
+        for note in result["notes"]:
+            console.print(f"  [neo.dim]•[/] {note}")

neo/commands/risk_commands.py

@@ -0,0 +1,68 @@
+"""Risk check command — neo risk."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from neo.auth import AuthManager
+from neo.client import AuthRequired, NeoClient
+from neo.display.formatters import fmt_price, fmt_pct, fmt_risk
+from neo.display.tables import kv_table
+from neo.display.theme import console, print_error, GREEN, GREEN_DIM
+
+
+@click.command()
+@click.option("--symbol", required=True, help="Ticker symbol")
+@click.option("--entry", required=True, type=float, help="Entry price")
+@click.option("--stop", required=True, type=float, help="Stop loss price")
+@click.option("--qty", required=True, type=int, help="Number of shares")
+@click.option("--equity", required=True, type=float, help="Account equity ($)")
+def risk(symbol: str, entry: float, stop: float, qty: int, equity: float) -> None:
+    """Check risk metrics for a trade."""
+    auth = AuthManager()
+    client = NeoClient(auth)
+
+    payload = {
+        "symbol": symbol.upper(),
+        "entry_price": entry,
+        "stop_price": stop,
+        "quantity": qty,
+        "equity": equity,
+    }
+
+    try:
+        with console.status(f"[{GREEN_DIM}]Analyzing risk...[/]"):
+            result = asyncio.run(client.post("/v1/risk/check", json=payload))
+    except AuthRequired:
+        print_error("Not authenticated. Run `neo login` first.")
+        raise SystemExit(1)
+    except Exception as e:
+        print_error(f"Risk check failed: {e}")
+        raise SystemExit(1)
+
+    risk_per_share = abs(entry - stop)
+    total_risk = risk_per_share * qty
+    risk_pct = (total_risk / equity * 100) if equity else 0
+    position_value = entry * qty
+
+    status = result.get("status", "PASS" if risk_pct <= 2.0 else "FAIL")
+    status_style = f"bold {GREEN}" if status == "PASS" else "bold red"
+
+    kv_table(f"RISK CHECK — {symbol.upper()}", {
+        "Status": f"[{status_style}]{status}[/]",
+        "Entry": fmt_price(entry),
+        "Stop": fmt_price(stop),
+        "Quantity": str(qty),
+        "Risk/Share": fmt_price(risk_per_share),
+        "Total Risk": fmt_risk(total_risk),
+        "Risk % of Equity": fmt_pct(risk_pct),
+        "Position Value": fmt_price(position_value),
+        "Position % of Equity": fmt_pct(position_value / equity * 100 if equity else 0),
+    })
+
+    # Show any warnings from the API
+    warnings = result.get("warnings", [])
+    for w in warnings:
+        console.print(f"  [neo.warn]![/] {w}")

neo/commands/scan_commands.py

@@ -0,0 +1,62 @@
+"""Scan command — neo scan SYMBOL."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from neo.auth import AuthManager
+from neo.client import AuthRequired, NeoClient
+from neo.display.formatters import fmt_price, fmt_pct
+from neo.display.tables import kv_table
+from neo.display.theme import console, print_error
+
+
+@click.command()
+@click.argument("symbol")
+@click.option("--scanner", default="default", help="Scanner ID to use")
+def scan(symbol: str, scanner: str) -> None:
+    """Scan a symbol for trading signals."""
+    auth = AuthManager()
+    client = NeoClient(auth)
+
+    try:
+        with console.status(f"[neo.green]Scanning {symbol.upper()}...[/]"):
+            result = asyncio.run(
+                client.post(
+                    f"/api/scanners/{scanner}/scan",
+                    json={"symbol": symbol.upper()},
+                )
+            )
+    except AuthRequired:
+        print_error("Not authenticated. Run `neo login` first.")
+        raise SystemExit(1)
+    except Exception as e:
+        print_error(f"Scan failed: {e}")
+        raise SystemExit(1)
+
+    # Build display from response
+    data: dict[str, str] = {"Symbol": symbol.upper()}
+
+    if "price" in result:
+        data["Price"] = fmt_price(result["price"])
+    if "change_pct" in result:
+        pct = result["change_pct"]
+        style = "bold green" if pct >= 0 else "bold red"
+        data["Change"] = f"[{style}]{fmt_pct(pct)}[/]"
+    if "trend" in result:
+        data["Trend"] = result["trend"]
+    if "signals" in result:
+        for sig in result["signals"]:
+            name = sig.get("name", "Signal")
+            value = sig.get("value", sig.get("direction", "—"))
+            data[name] = str(value)
+    if "support" in result:
+        data["Support"] = fmt_price(result["support"])
+    if "resistance" in result:
+        data["Resistance"] = fmt_price(result["resistance"])
+    if "score" in result:
+        data["Score"] = str(result["score"])
+
+    kv_table(f"SCAN — {symbol.upper()}", data)

neo/commands/size_commands.py

@@ -0,0 +1,60 @@
+"""Position sizing command — neo size."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from neo.auth import AuthManager
+from neo.client import AuthRequired, NeoClient
+from neo.display.formatters import fmt_price, fmt_pct, fmt_qty, fmt_risk
+from neo.display.tables import kv_table
+from neo.display.theme import GREEN_DIM, console, print_error
+
+
+@click.command()
+@click.option("--equity", required=True, type=float, help="Account equity ($)")
+@click.option("--entry", required=True, type=float, help="Entry price")
+@click.option("--stop", required=True, type=float, help="Stop loss price")
+@click.option("--direction", type=click.Choice(["long", "short"]), default="long", help="Trade direction")
+@click.option("--risk-pct", type=float, default=1.0, help="Risk per trade (%, default 1.0)")
+def size(equity: float, entry: float, stop: float, direction: str, risk_pct: float) -> None:
+    """Calculate position size for a trade."""
+    auth = AuthManager()
+    client = NeoClient(auth)
+
+    payload = {
+        "equity": equity,
+        "entry_price": entry,
+        "stop_price": stop,
+        "direction": direction,
+        "risk_percent": risk_pct,
+    }
+
+    try:
+        with console.status(f"[{GREEN_DIM}]Computing...[/]"):
+            result = asyncio.run(client.post("/v1/sizing/calculate", json=payload))
+    except AuthRequired:
+        print_error("Not authenticated. Run `neo login` first.")
+        raise SystemExit(1)
+    except Exception as e:
+        print_error(f"Sizing failed: {e}")
+        raise SystemExit(1)
+
+    risk_per_share = abs(entry - stop)
+    risk_amount = result.get("risk_amount", equity * risk_pct / 100)
+    shares = result.get("shares", int(risk_amount / risk_per_share) if risk_per_share else 0)
+    position_value = result.get("position_value", shares * entry)
+
+    kv_table("POSITION SIZE", {
+        "Direction": direction.upper(),
+        "Entry": fmt_price(entry),
+        "Stop": fmt_price(stop),
+        "Risk/Share": fmt_price(risk_per_share),
+        "Risk Amount": fmt_risk(risk_amount),
+        "Risk %": fmt_pct(risk_pct),
+        "Shares": fmt_qty(shares),
+        "Position Value": fmt_price(position_value),
+        "% of Equity": fmt_pct(position_value / equity * 100 if equity else 0),
+    })

neo/config.py

@@ -0,0 +1,70 @@
+"""System R CLI configuration — paths, settings, defaults."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+# Base directory for all System R local data
+SYSTEMR_HOME = Path(os.environ.get("SYSTEMR_HOME", Path.home() / ".systemr"))
+
+# File paths
+AUTH_FILE = SYSTEMR_HOME / "auth.json"
+DB_FILE = SYSTEMR_HOME / "journal.db"
+CONFIG_FILE = SYSTEMR_HOME / "config.json"
+PROFILE_FILE = SYSTEMR_HOME / "PROFILE.md"
+RULES_FILE = SYSTEMR_HOME / "RULES.md"
+MEMORY_DIR = SYSTEMR_HOME / "memory"
+MEMORY_INDEX = MEMORY_DIR / "MEMORY.md"
+SESSIONS_DIR = SYSTEMR_HOME / "sessions"
+
+# API base URLs
+DEFAULT_API_URL = "https://agents.systemr.ai"
+STAGING_API_URL = "https://app-staging.systemr.ai"
+
+# Backward compat aliases (additive-only rule — old names still work)
+NEO_HOME = SYSTEMR_HOME
+
+
+def get_api_url() -> str:
+    """Return the API base URL, respecting SYSTEMR_API_URL env override.
+
+    Validates HTTPS for non-localhost URLs to prevent credential leaks
+    over plaintext connections.
+
+    Returns:
+        The API base URL string.
+
+    Raises:
+        ValueError: If the URL uses HTTP for a non-localhost host.
+    """
+    # Check new name first, fall back to old name for backward compat
+    url = os.environ.get(
+        "SYSTEMR_API_URL",
+        os.environ.get("NEO_API_URL", DEFAULT_API_URL),
+    )
+    if (
+        not url.startswith("https://")
+        and "localhost" not in url
+        and "127.0.0.1" not in url
+    ):
+        raise ValueError(
+            f"SYSTEMR_API_URL must use HTTPS (got: {url}). "
+            "Only localhost URLs are allowed over HTTP."
+        )
+    return url
+
+
+def ensure_systemr_home() -> None:
+    """Create ~/.systemr/ with secure permissions if it doesn't exist.
+
+    Creates the base directory plus memory/ and sessions/ subdirectories.
+    All directories use mode 0o700 (owner read/write/execute only).
+    """
+    SYSTEMR_HOME.mkdir(mode=0o700, parents=True, exist_ok=True)
+    MEMORY_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
+    SESSIONS_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+
+# Backward compat alias
+ensure_neo_home = ensure_systemr_home

neo/confirmation.py

@@ -0,0 +1,311 @@
+"""Trade confirmation flow — mandatory safety layer.
+
+Permission levels (from DESIGN.md §9):
+  AUTO           — read-only, calculations: no confirmation needed
+  CONFIRM        — place/cancel/modify order: show details, wait for y/n
+  DOUBLE_CONFIRM — kill switch: show warning, require typing KILL
+
+SAFETY: Unknown actions default to CONFIRM, not AUTO. Any new tool
+added to the backend requires explicit approval until classified.
+
+All financial values in confirmation functions use Decimal.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from enum import Enum
+from typing import Any
+
+import click
+import structlog
+
+from neo.display.theme import (
+    GREEN,
+    RED,
+    GRAY,
+    console,
+)
+from neo.types import Price, RiskAmount, Percentage, Quantity
+
+logger = structlog.get_logger(module="confirmation")
+
+
+class PermissionLevel(Enum):
+    """Permission level for tool actions."""
+
+    AUTO = "auto"
+    CONFIRM = "confirm"
+    DOUBLE_CONFIRM = "double_confirm"
+
+
+# Actions mapped to permission levels.
+# SAFETY: default is CONFIRM for unknown actions (see get_permission_level).
+ACTION_PERMISSIONS: dict[str, PermissionLevel] = {
+    # Auto — no confirmation needed (read-only and calculations)
+    "get_quote": PermissionLevel.AUTO,
+    "get_account_balance": PermissionLevel.AUTO,
+    "calculate_position_size": PermissionLevel.AUTO,
+    "check_trade_risk": PermissionLevel.AUTO,
+    "evaluate_performance": PermissionLevel.AUTO,
+    "get_pricing": PermissionLevel.AUTO,
+    "get_positions": PermissionLevel.AUTO,
+    "get_portfolio": PermissionLevel.AUTO,
+    "get_order_status": PermissionLevel.AUTO,
+    "search_memory": PermissionLevel.AUTO,
+    "get_trading_biases": PermissionLevel.AUTO,
+    "record_trade_outcome": PermissionLevel.AUTO,
+    "store_memory": PermissionLevel.AUTO,
+    # Confirm — show details, wait for y/n (actions touching money)
+    "place_order": PermissionLevel.CONFIRM,
+    "cancel_order": PermissionLevel.CONFIRM,
+    "modify_order": PermissionLevel.CONFIRM,
+    "close_position": PermissionLevel.CONFIRM,
+    "set_stop_loss": PermissionLevel.CONFIRM,
+    "modify_stop": PermissionLevel.CONFIRM,
+    "set_take_profit": PermissionLevel.CONFIRM,
+    "connect_broker": PermissionLevel.CONFIRM,
+    "disconnect_broker": PermissionLevel.CONFIRM,
+    # Double confirm — type to confirm (destructive/irreversible)
+    "kill_switch": PermissionLevel.DOUBLE_CONFIRM,
+    "close_all_positions": PermissionLevel.DOUBLE_CONFIRM,
+    "enable_margin": PermissionLevel.DOUBLE_CONFIRM,
+    "withdraw_funds": PermissionLevel.DOUBLE_CONFIRM,
+}
+
+
+# ── Permission profiles ────────────────────────────────────────────
+# Named profiles configure safety tiers for different user levels.
+# Inspired by OpenClaw's tool profiles (messaging/minimal/automation).
+
+# Profile overrides: maps action names to elevated/demoted permission levels.
+# Actions not in overrides use the default ACTION_PERMISSIONS mapping.
+PERMISSION_PROFILES: dict[str, dict[str, PermissionLevel]] = {
+    "paper": {
+        # Maximum safety — ALL trade actions require DOUBLE_CONFIRM
+        "place_order": PermissionLevel.DOUBLE_CONFIRM,
+        "cancel_order": PermissionLevel.DOUBLE_CONFIRM,
+        "modify_order": PermissionLevel.DOUBLE_CONFIRM,
+        "close_position": PermissionLevel.DOUBLE_CONFIRM,
+        "set_stop_loss": PermissionLevel.DOUBLE_CONFIRM,
+        "modify_stop": PermissionLevel.DOUBLE_CONFIRM,
+        "set_take_profit": PermissionLevel.DOUBLE_CONFIRM,
+        "connect_broker": PermissionLevel.DOUBLE_CONFIRM,
+    },
+    "standard": {},  # Empty — uses ACTION_PERMISSIONS as-is
+    "experienced": {
+        # Relaxed — stop/target adjustments auto-approved
+        "set_stop_loss": PermissionLevel.AUTO,
+        "modify_stop": PermissionLevel.AUTO,
+        "set_take_profit": PermissionLevel.AUTO,
+    },
+}
+
+# Active profile — set via /permissions command or config.json
+_active_profile: str = "standard"
+
+
+def get_active_profile() -> str:
+    """Return the name of the active permission profile.
+
+    Returns:
+        Profile name string.
+    """
+    return _active_profile
+
+
+def set_active_profile(profile: str) -> bool:
+    """Set the active permission profile and persist to config.json.
+
+    Args:
+        profile: Profile name (paper, standard, experienced).
+
+    Returns:
+        True if profile was set, False if unknown.
+    """
+    global _active_profile
+    if profile not in PERMISSION_PROFILES:
+        return False
+    _active_profile = profile
+    _save_profile_to_config(profile)
+    logger.info("permission_profile_changed", profile=profile)
+    return True
+
+
+def load_profile_from_config() -> None:
+    """Load the permission profile from config.json on startup.
+
+    Reads the 'permission_profile' key from ~/.systemr/config.json.
+    Falls back to 'standard' if not set or invalid.
+    """
+    global _active_profile
+    import json
+    from neo.config import CONFIG_FILE
+
+    if not CONFIG_FILE.exists():
+        return
+
+    try:
+        config = json.loads(CONFIG_FILE.read_text())
+        profile = config.get("permission_profile", "standard")
+        if profile in PERMISSION_PROFILES:
+            _active_profile = profile
+            logger.info("permission_profile_loaded", profile=profile)
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+
+def _save_profile_to_config(profile: str) -> None:
+    """Persist the active permission profile to config.json.
+
+    Args:
+        profile: Profile name to save.
+    """
+    import json
+    from neo.config import CONFIG_FILE, ensure_systemr_home
+
+    ensure_systemr_home()
+    config: dict = {}
+    if CONFIG_FILE.exists():
+        try:
+            config = json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, TypeError):
+            config = {}
+
+    config["permission_profile"] = profile
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+
+
+def get_permission_level(action: str) -> PermissionLevel:
+    """Get the permission level for a given action under active profile.
+
+    Resolution order:
+    1. Active profile overrides (if action is in profile)
+    2. Default ACTION_PERMISSIONS mapping
+    3. CONFIRM (safety default for unknown actions)
+
+    Args:
+        action: Tool/action name from the backend.
+
+    Returns:
+        The permission level for this action.
+    """
+    # Check active profile overrides first
+    profile_overrides = PERMISSION_PROFILES.get(_active_profile, {})
+    if action in profile_overrides:
+        return profile_overrides[action]
+    return ACTION_PERMISSIONS.get(action, PermissionLevel.CONFIRM)
+
+
+def confirm_trade(
+    symbol: str,
+    direction: str,
+    entry: Price,
+    stop: Price,
+    shares: Quantity,
+    risk_amount: RiskAmount,
+    risk_pct: Percentage,
+    target: Price | None = None,
+    rr_ratio: Decimal | None = None,
+    position_value: Price | None = None,
+) -> bool:
+    """Show trade card and ask for confirmation.
+
+    All financial values are Decimal. Returns True if the user approves.
+
+    Args:
+        symbol: Ticker symbol.
+        direction: "long" or "short".
+        entry: Entry price.
+        stop: Stop loss price.
+        shares: Number of shares.
+        risk_amount: Total risk in dollars.
+        risk_pct: Risk as percentage of account.
+        target: Optional target price.
+        rr_ratio: Optional reward-to-risk ratio.
+        position_value: Optional total position value.
+
+    Returns:
+        True if user typed 'y', False otherwise.
+    """
+    from neo.display.formatters import fmt_price, fmt_qty, fmt_risk, fmt_pct
+
+    dir_color = GREEN if direction.lower() == "long" else RED
+    console.print()
+    console.print(f"  ┌─ [{GREEN}]TRADE — {symbol.upper()}[/] {'─' * 30}┐")
+    console.print(f"  │  Direction   [{dir_color}]{direction.upper()}[/]")
+    console.print(f"  │  Entry       {fmt_price(entry)}")
+    console.print(f"  │  Stop        {fmt_price(stop)}")
+    if target is not None:
+        console.print(f"  │  Target      {fmt_price(target)}")
+    console.print(f"  │  Shares      {fmt_qty(shares)}")
+    console.print(f"  │  Risk        {fmt_risk(risk_amount)} ({fmt_pct(risk_pct)})")
+    if rr_ratio is not None:
+        console.print(f"  │  R:R         1 : {float(rr_ratio):.1f}")
+    if position_value is not None:
+        console.print(f"  │  Position    {fmt_price(position_value)}")
+    console.print(f"  └{'─' * 45}┘")
+    console.print()
+
+    try:
+        response = click.prompt(
+            click.style("  Place this trade? [y/n]", fg="white"),
+            type=click.Choice(["y", "n"], case_sensitive=False),
+            show_choices=False,
+        )
+        approved = response.lower() == "y"
+        logger.info(
+            "trade_confirmation",
+            symbol=symbol, direction=direction, approved=approved,
+            risk=str(risk_amount), shares=shares,
+        )
+        return approved
+    except (click.Abort, EOFError):
+        logger.info("trade_confirmation", symbol=symbol, approved=False, reason="aborted")
+        return False
+
+
+def confirm_kill_switch(
+    positions: list[dict[str, Any]] | None = None,
+) -> bool:
+    """Double confirmation for kill switch — requires typing KILL.
+
+    This is the most dangerous action. It closes ALL open positions.
+
+    Args:
+        positions: Optional list of position dicts to display.
+
+    Returns:
+        True only if user types exactly "KILL".
+    """
+    console.print()
+    console.print(f"  [{RED}]{'━' * 48}[/]")
+    console.print(f"  [{RED}]KILL SWITCH — This will close ALL open positions.[/]")
+    console.print(f"  [{RED}]{'━' * 48}[/]")
+
+    if positions:
+        console.print()
+        for p in positions:
+            symbol = p.get("symbol", "?")
+            qty = p.get("quantity", 0)
+            pnl = p.get("pnl", 0)
+            pnl_color = GREEN if float(pnl) >= 0 else RED
+            console.print(
+                f"  [{GRAY}]{symbol}  {qty} shares  "
+                f"[{pnl_color}]{'+' if float(pnl) >= 0 else ''}{float(pnl):.2f}[/][/]"
+            )
+
+    console.print()
+
+    try:
+        response = click.prompt(
+            click.style("  Type KILL to confirm", fg="red", bold=True),
+            default="",
+            show_default=False,
+        )
+        approved = response.strip() == "KILL"
+        logger.info("kill_switch_confirmation", approved=approved)
+        return approved
+    except (click.Abort, EOFError):
+        logger.info("kill_switch_confirmation", approved=False, reason="aborted")
+        return False