systemr-cli 1.0.0__py3-none-any.whl

neo/commands/cron_commands.py

@@ -0,0 +1,179 @@
+"""Cron commands — manage scheduled tasks from the CLI.
+
+Usage:
+  systemr cron list           — show all scheduled jobs
+  systemr cron add            — create a new job
+  systemr cron remove <id>    — delete a job
+  systemr cron run <id>       — force-run a job now
+  systemr cron runs <id>      — show run history
+
+No bare print() — all output via Rich console. Logging via structlog.
+"""
+
+from __future__ import annotations
+
+import click
+import structlog
+
+from neo.cron import (
+    CronJob,
+    Schedule,
+    ScheduleKind,
+    add_job,
+    get_job,
+    get_runs,
+    load_jobs,
+    remove_job,
+)
+from neo.display.theme import (
+    AMBER,
+    DIM,
+    GRAY,
+    GREEN,
+    RED,
+    WHITE,
+    ICON_ERROR,
+    ICON_SUCCESS,
+    console,
+    print_error,
+    print_success,
+)
+
+logger = structlog.get_logger(module="cron_commands")
+
+
+@click.group()
+def cron() -> None:
+    """Manage scheduled tasks."""
+    pass
+
+
+@cron.command("list")
+def cron_list() -> None:
+    """List all scheduled jobs."""
+    jobs = load_jobs()
+    if not jobs:
+        console.print(f"  [{DIM}]No scheduled tasks.[/]")
+        console.print(f"  [{DIM}]Create one: systemr cron add --name 'Morning scan' --message 'Run morning briefing'[/]")
+        return
+
+    console.print()
+    console.print(f"  [{GRAY}]Scheduled tasks ({len(jobs)})[/]")
+    console.print()
+    for j in jobs:
+        status_icon = f"[{GREEN}]{ICON_SUCCESS}[/]" if j.enabled else f"[{DIM}]○[/]"
+        kind = j.schedule.kind.value
+        detail = ""
+        if j.schedule.kind == ScheduleKind.AT and j.schedule.at:
+            detail = j.schedule.at[:19]
+        elif j.schedule.kind == ScheduleKind.EVERY and j.schedule.every_seconds:
+            mins = j.schedule.every_seconds / 60
+            detail = f"every {mins:.0f}m"
+        elif j.schedule.kind == ScheduleKind.CRON and j.schedule.expr:
+            detail = j.schedule.expr
+            if j.schedule.tz:
+                detail += f" ({j.schedule.tz})"
+
+        console.print(
+            f"  {status_icon} [{WHITE}]{j.name:<24}[/] "
+            f"[{DIM}]{detail:<30}[/] "
+            f"[{DIM}]runs: {j.run_count}[/]  "
+            f"[{DIM}]{j.id}[/]"
+        )
+    console.print()
+
+
+@cron.command()
+@click.option("--name", required=True, help="Job name")
+@click.option("--message", required=True, help="Prompt to send when job fires")
+@click.option("--cron-expr", "expr", default=None, help="Cron expression (e.g., '0 7 * * 1-5')")
+@click.option("--every", "every_seconds", type=float, default=None, help="Interval in seconds")
+@click.option("--at", "at_time", default=None, help="ISO 8601 timestamp for one-shot")
+@click.option("--tz", default=None, help="IANA timezone (e.g., 'America/New_York')")
+@click.option("--model", default=None, help="Model override for this job")
+def add(
+    name: str,
+    message: str,
+    expr: str | None,
+    every_seconds: float | None,
+    at_time: str | None,
+    tz: str | None,
+    model: str | None,
+) -> None:
+    """Create a new scheduled job."""
+    if expr:
+        schedule = Schedule(kind=ScheduleKind.CRON, expr=expr, tz=tz)
+        desc = f"cron: {expr}"
+    elif every_seconds:
+        schedule = Schedule(kind=ScheduleKind.EVERY, every_seconds=every_seconds)
+        desc = f"every {every_seconds / 60:.0f}m"
+    elif at_time:
+        schedule = Schedule(kind=ScheduleKind.AT, at=at_time)
+        desc = f"at: {at_time[:19]}"
+    else:
+        # Default: every 1 hour
+        schedule = Schedule(kind=ScheduleKind.EVERY, every_seconds=3600)
+        desc = "every 60m (default)"
+
+    delete_after = schedule.kind == ScheduleKind.AT
+    job = add_job(name, message, schedule, model=model, delete_after_run=delete_after)
+    print_success(f"Created: {job.name} — {desc} ({job.id})")
+
+
+@cron.command()
+@click.argument("job_id")
+def remove(job_id: str) -> None:
+    """Remove a scheduled job by ID."""
+    if remove_job(job_id):
+        print_success(f"Removed: {job_id}")
+    else:
+        print_error(f"Job not found: {job_id}")
+
+
+@cron.command()
+@click.argument("job_id")
+def run(job_id: str) -> None:
+    """Force-run a job now (sends its message to the backend)."""
+    job = get_job(job_id)
+    if not job:
+        print_error(f"Job not found: {job_id}")
+        return
+    console.print(f"  [{GRAY}]Running:[/] [{WHITE}]{job.name}[/]")
+    console.print(f"  [{DIM}]Message: {job.message[:80]}[/]")
+    console.print(f"  [{AMBER}]Note: Manual run queued. Use `systemr chat` to see results.[/]")
+    logger.info("cron_manual_run", job_id=job_id, name=job.name)
+
+
+@cron.command()
+@click.argument("job_id")
+@click.option("--limit", default=20, help="Max records to show")
+def runs(job_id: str, limit: int) -> None:
+    """Show run history for a job."""
+    job = get_job(job_id)
+    if not job:
+        print_error(f"Job not found: {job_id}")
+        return
+
+    records = get_runs(job_id, limit=limit)
+    if not records:
+        console.print(f"  [{DIM}]No runs recorded for {job.name}[/]")
+        return
+
+    console.print()
+    console.print(f"  [{GRAY}]Run history: {job.name} (last {len(records)})[/]")
+    console.print()
+    for r in records:
+        status = r.get("status", "unknown")
+        if status == "ok":
+            icon = f"[{GREEN}]{ICON_SUCCESS}[/]"
+        else:
+            icon = f"[{RED}]{ICON_ERROR}[/]"
+        run_at = r.get("run_at", "")[:19]
+        duration = r.get("duration_seconds", 0)
+        msg = r.get("message", "")
+        console.print(
+            f"  {icon} [{WHITE}]{run_at}[/]  "
+            f"[{DIM}]{duration:.1f}s[/]  "
+            f"[{DIM}]{msg[:60]}[/]" if msg else f"  {icon} [{WHITE}]{run_at}[/]  [{DIM}]{duration:.1f}s[/]"
+        )
+    console.print()

neo/commands/doctor_command.py

@@ -0,0 +1,178 @@
+"""Doctor command — health check and diagnostic tool.
+
+Checks: API connectivity, auth validity, profile completeness,
+rules loaded, local DB integrity, credit balance, Python version.
+Exit codes: 0=healthy, 1=errors, 2=warnings.
+
+Inspired by OpenClaw's `openclaw doctor` + `openclaw status --deep`.
+No bare print() — all output via Rich console. Logging via structlog.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import sys
+
+import click
+import structlog
+
+from neo.auth import AuthManager
+from neo.config import (
+    DB_FILE,
+    PROFILE_FILE,
+    RULES_FILE,
+    MEMORY_DIR,
+    SYSTEMR_HOME,
+    get_api_url,
+)
+from neo.display.theme import (
+    AMBER,
+    DIM,
+    GREEN,
+    GRAY,
+    RED,
+    WHITE,
+    ICON_ERROR,
+    ICON_SUCCESS,
+    ICON_WARN,
+    console,
+    print_banner,
+    print_separator,
+)
+
+logger = structlog.get_logger(module="doctor")
+
+
+@click.command()
+def doctor() -> None:
+    """Run health checks on System R CLI."""
+    print_banner()
+    print_separator()
+    console.print(f"  [{GRAY}]Running diagnostics...[/]\n")
+
+    checks: list[tuple[str, str, str]] = []  # (name, status, detail)
+
+    # 1. Python version
+    v = sys.version_info
+    if v >= (3, 11):
+        checks.append(("Python version", "ok", f"{v.major}.{v.minor}.{v.micro}"))
+    else:
+        checks.append(("Python version", "error", f"{v.major}.{v.minor} (need >=3.11)"))
+
+    # 2. SYSTEMR_HOME exists
+    if SYSTEMR_HOME.exists():
+        checks.append(("~/.systemr/ directory", "ok", str(SYSTEMR_HOME)))
+    else:
+        checks.append(("~/.systemr/ directory", "warn", "not created yet — run `systemr setup`"))
+
+    # 3. API connectivity
+    api_url = get_api_url()
+    try:
+        import httpx
+        resp = httpx.get(f"{api_url}/health", timeout=5.0)
+        if resp.status_code == 200:
+            checks.append(("API connectivity", "ok", api_url))
+        else:
+            checks.append(("API connectivity", "error", f"{api_url} returned {resp.status_code}"))
+    except Exception as exc:
+        checks.append(("API connectivity", "error", f"{api_url} — {exc}"))
+
+    # 4. Auth token
+    auth = AuthManager()
+    token = auth.get_token()
+    if token is not None:
+        checks.append(("Authentication", "ok", f"logged in as {token.email}"))
+    else:
+        checks.append(("Authentication", "error", "not authenticated — run `systemr login`"))
+
+    # 5. Profile
+    if PROFILE_FILE.exists():
+        content = PROFILE_FILE.read_text()
+        has_name = "Name:" in content and "(none)" not in content
+        has_risk = "Max risk per trade:" in content
+        if has_name and has_risk:
+            checks.append(("Trader profile", "ok", "PROFILE.md complete"))
+        else:
+            checks.append(("Trader profile", "warn", "PROFILE.md incomplete — run `systemr setup`"))
+    else:
+        checks.append(("Trader profile", "warn", "no PROFILE.md — run `systemr setup`"))
+
+    # 6. Rules
+    if RULES_FILE.exists():
+        content = RULES_FILE.read_text()
+        if "(none set)" not in content:
+            checks.append(("Trading rules", "ok", "RULES.md has rules defined"))
+        else:
+            checks.append(("Trading rules", "warn", "RULES.md has no rules — add via `systemr setup`"))
+    else:
+        checks.append(("Trading rules", "warn", "no RULES.md — run `systemr setup`"))
+
+    # 7. Local DB integrity
+    if DB_FILE.exists():
+        try:
+            conn = sqlite3.connect(str(DB_FILE))
+            result = conn.execute("PRAGMA integrity_check").fetchone()
+            conn.close()
+            if result and result[0] == "ok":
+                checks.append(("Journal database", "ok", "integrity check passed"))
+            else:
+                checks.append(("Journal database", "error", f"integrity check: {result}"))
+        except Exception as exc:
+            checks.append(("Journal database", "error", f"cannot open: {exc}"))
+    else:
+        checks.append(("Journal database", "warn", "no journal.db — will be created on first use"))
+
+    # 8. Memory directory
+    if MEMORY_DIR.exists():
+        file_count = len(list(MEMORY_DIR.glob("*.md")))
+        checks.append(("Memory files", "ok", f"{file_count} files in ~/.systemr/memory/"))
+    else:
+        checks.append(("Memory files", "warn", "memory directory not created yet"))
+
+    # 9. Credit balance (only if authenticated)
+    if token is not None:
+        try:
+            import httpx
+            resp = httpx.get(
+                f"{api_url}/v1/billing/balance",
+                headers={"Authorization": f"Bearer {token.access_token}"},
+                timeout=5.0,
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                balance = data.get("balance", data.get("credits", "unknown"))
+                checks.append(("Credit balance", "ok", f"{balance} credits"))
+            else:
+                checks.append(("Credit balance", "warn", f"could not fetch (HTTP {resp.status_code})"))
+        except Exception:
+            checks.append(("Credit balance", "warn", "could not fetch balance"))
+
+    # Display results
+    errors = 0
+    warnings = 0
+    for name, status, detail in checks:
+        if status == "ok":
+            icon = f"[{GREEN}]{ICON_SUCCESS}[/]"
+        elif status == "warn":
+            icon = f"[{AMBER}]{ICON_WARN}[/]"
+            warnings += 1
+        else:
+            icon = f"[{RED}]{ICON_ERROR}[/]"
+            errors += 1
+        console.print(f"  {icon} [{WHITE}]{name:<20}[/] [{DIM}]{detail}[/]")
+
+    console.print()
+    if errors > 0:
+        console.print(f"  [{RED}]{errors} error(s)[/] [{DIM}]found. Fix before using System R.[/]")
+    elif warnings > 0:
+        console.print(f"  [{AMBER}]{warnings} warning(s)[/] [{DIM}]— System R will work but some features may be limited.[/]")
+    else:
+        console.print(f"  [{GREEN}]All checks passed.[/] [{DIM}]System R is ready.[/]")
+    console.print()
+
+    logger.info("doctor_complete", errors=errors, warnings=warnings)
+
+    if errors > 0:
+        raise SystemExit(1)
+    if warnings > 0:
+        raise SystemExit(2)

neo/commands/eval_commands.py

@@ -0,0 +1,73 @@
+"""Trade evaluation command — neo eval."""
+
+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_r
+from neo.display.tables import kv_table
+from neo.display.theme import console, print_error, GREEN, GREEN_DIM
+
+
+@click.command()
+@click.argument("r_multiples", nargs=-1, type=float, required=True)
+@click.option("--tier", type=click.Choice(["basic", "full", "pro"]), default="basic", help="Evaluation tier")
+def eval(r_multiples: tuple[float, ...], tier: str) -> None:
+    """Evaluate a series of R-multiples.
+
+    Example: neo eval 1.5 -1.0 2.3 0.8 -1.0
+    """
+    auth = AuthManager()
+    client = NeoClient(auth)
+
+    payload = {
+        "r_multiples": list(r_multiples),
+    }
+
+    try:
+        with console.status(f"[{GREEN_DIM}]Processing...[/]"):
+            result = asyncio.run(client.post(f"/v1/eval/{tier}", json=payload))
+    except AuthRequired:
+        print_error("Not authenticated. Run `neo login` first.")
+        raise SystemExit(1)
+    except Exception as e:
+        print_error(f"Evaluation failed: {e}")
+        raise SystemExit(1)
+
+    # Display results
+    total_r = sum(r_multiples)
+    win_count = sum(1 for r in r_multiples if r > 0)
+    loss_count = sum(1 for r in r_multiples if r <= 0)
+    win_rate = win_count / len(r_multiples) * 100 if r_multiples else 0
+
+    display_data = {
+        "Trades": str(len(r_multiples)),
+        "Wins": str(win_count),
+        "Losses": str(loss_count),
+        "Win Rate": f"{win_rate:.1f}%",
+        "Total R": fmt_r(total_r),
+        "Avg R": fmt_r(total_r / len(r_multiples)) if r_multiples else "0.00R",
+    }
+
+    # Add API-provided metrics
+    if "expectancy" in result:
+        display_data["Expectancy"] = fmt_r(result["expectancy"])
+    if "g_score" in result:
+        score = result["g_score"]
+        style = f"bold {GREEN}" if score >= 50 else "bold red"
+        display_data["G-Score"] = f"[{style}]{score:.1f}[/]"
+    if "edge_ratio" in result:
+        display_data["Edge Ratio"] = f"{result['edge_ratio']:.2f}"
+
+    kv_table("TRADE EVALUATION", display_data)
+
+    # R-multiple sequence
+    r_display = " ".join(
+        f"[bold green]{fmt_r(r)}[/]" if r > 0 else f"[bold red]{fmt_r(r)}[/]"
+        for r in r_multiples
+    )
+    console.print(f"\n  Sequence: {r_display}")

neo/commands/journal_commands.py

@@ -0,0 +1,197 @@
+"""Journal commands — local trade journal (SQLite)."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+
+import click
+
+from neo.display.formatters import direction_style, fmt_price, fmt_qty, fmt_r
+from neo.display.tables import data_table, kv_table
+from neo.display.theme import console, print_error, print_success
+from neo.store import LocalStore
+
+
+@click.group()
+def journal() -> None:
+    """Local trade journal — stored on your machine."""
+    pass
+
+
+@journal.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("--direction", type=click.Choice(["long", "short"]), default="long")
+@click.option("--qty", required=True, type=int, help="Number of shares")
+@click.option("--date", default=None, help="Entry date (YYYY-MM-DD, default today)")
+@click.option("--notes", default=None, help="Trade notes")
+@click.option("--tags", default=None, help="Comma-separated tags")
+def add(symbol: str, entry: float, stop: float, direction: str, qty: int, date: str | None, notes: str | None, tags: str | None) -> None:
+    """Add a trade to the journal."""
+    store = LocalStore()
+    trade_id = store.add_trade(
+        symbol=symbol,
+        direction=direction,
+        entry_price=entry,
+        stop_price=stop,
+        quantity=qty,
+        entry_date=date,
+        notes=notes,
+        tags=tags,
+    )
+    print_success(f"Trade #{trade_id} added — {symbol.upper()} {direction.upper()} {qty} @ {fmt_price(entry)}")
+
+
+@journal.command("list")
+@click.option("--symbol", default=None, help="Filter by symbol")
+@click.option("--limit", default=20, type=int, help="Max trades to show")
+def list_trades(symbol: str | None, limit: int) -> None:
+    """List recent trades."""
+    store = LocalStore()
+    trades = store.list_trades(limit=limit, symbol=symbol)
+    if not trades:
+        console.print("[neo.dim]No trades found.[/]")
+        return
+
+    rows = []
+    for t in trades:
+        r_str = fmt_r(t["r_multiple"]) if t["r_multiple"] is not None else "—"
+        dir_style = direction_style(t["direction"])
+        rows.append([
+            str(t["id"]),
+            t["entry_date"][:10],
+            t["symbol"],
+            f"[{dir_style}]{t['direction'].upper()}[/]",
+            fmt_price(t["entry_price"]),
+            fmt_price(t["stop_price"]),
+            fmt_qty(t["quantity"]),
+            r_str,
+        ])
+
+    data_table(
+        "TRADE JOURNAL",
+        [
+            ("#", "dim"),
+            ("Date", ""),
+            ("Symbol", "bold"),
+            ("Dir", ""),
+            ("Entry", ""),
+            ("Stop", ""),
+            ("Qty", ""),
+            ("R", ""),
+        ],
+        rows,
+    )
+
+
+@journal.command()
+@click.argument("trade_id", type=int)
+def show(trade_id: int) -> None:
+    """Show details of a specific trade."""
+    store = LocalStore()
+    t = store.get_trade(trade_id)
+    if not t:
+        print_error(f"Trade #{trade_id} not found.")
+        raise SystemExit(1)
+
+    data = {
+        "Symbol": t["symbol"],
+        "Direction": t["direction"].upper(),
+        "Entry": fmt_price(t["entry_price"]),
+        "Stop": fmt_price(t["stop_price"]),
+        "Quantity": fmt_qty(t["quantity"]),
+        "Entry Date": t["entry_date"],
+    }
+    if t["exit_price"] is not None:
+        data["Exit"] = fmt_price(t["exit_price"])
+    if t["exit_date"]:
+        data["Exit Date"] = t["exit_date"]
+    if t["r_multiple"] is not None:
+        data["R-Multiple"] = fmt_r(t["r_multiple"])
+    if t["notes"]:
+        data["Notes"] = t["notes"]
+    if t["tags"]:
+        data["Tags"] = t["tags"]
+
+    kv_table(f"TRADE #{trade_id}", data)
+
+
+@journal.command()
+@click.argument("trade_id", type=int)
+@click.option("--exit-price", type=float, help="Exit price")
+@click.option("--exit-date", type=str, help="Exit date (YYYY-MM-DD)")
+@click.option("--r-multiple", type=float, help="R-multiple result")
+@click.option("--notes", type=str, help="Update notes")
+@click.option("--tags", type=str, help="Update tags")
+def edit(trade_id: int, exit_price: float | None, exit_date: str | None, r_multiple: float | None, notes: str | None, tags: str | None) -> None:
+    """Edit a trade in the journal."""
+    store = LocalStore()
+    updated = store.update_trade(
+        trade_id,
+        exit_price=exit_price,
+        exit_date=exit_date,
+        r_multiple=r_multiple,
+        notes=notes,
+        tags=tags,
+    )
+    if updated:
+        print_success(f"Trade #{trade_id} updated.")
+        # Auto-save lesson for significant losses (R < -1)
+        if r_multiple is not None and r_multiple < -1.0:
+            trade = store.get_trade(trade_id)
+            if trade:
+                from neo.profile import auto_save_trade_lesson
+                auto_save_trade_lesson(
+                    symbol=str(trade["symbol"]),
+                    r_multiple=str(r_multiple),
+                    direction=str(trade["direction"]),
+                    entry=str(trade["entry_price"]),
+                    exit_price=str(exit_price or trade.get("exit_price", 0)),
+                    notes=notes or str(trade.get("notes", "")),
+                )
+                print_success("Lesson auto-saved to memory.")
+    else:
+        print_error(f"Trade #{trade_id} not found or no changes.")
+
+
+@journal.command()
+@click.argument("trade_id", type=int)
+@click.confirmation_option(prompt="Are you sure you want to delete this trade?")
+def delete(trade_id: int) -> None:
+    """Delete a trade from the journal."""
+    store = LocalStore()
+    if store.delete_trade(trade_id):
+        print_success(f"Trade #{trade_id} deleted.")
+    else:
+        print_error(f"Trade #{trade_id} not found.")
+
+
+@journal.command()
+@click.option("--format", "fmt", type=click.Choice(["csv", "json"]), default="csv", help="Export format")
+@click.option("--output", "-o", type=click.Path(), default=None, help="Output file (default: stdout)")
+def export(fmt: str, output: str | None) -> None:
+    """Export all trades."""
+    store = LocalStore()
+    trades = store.export_trades()
+    if not trades:
+        console.print("[neo.dim]No trades to export.[/]")
+        return
+
+    if fmt == "json":
+        text = json.dumps(trades, indent=2)
+    else:
+        buf = io.StringIO()
+        writer = csv.DictWriter(buf, fieldnames=trades[0].keys())
+        writer.writeheader()
+        writer.writerows(trades)
+        text = buf.getvalue()
+
+    if output:
+        with open(output, "w") as f:
+            f.write(text)
+        print_success(f"Exported {len(trades)} trades to {output}")
+    else:
+        console.print(text)