tracellm-cli 0.1.0__py3-none-any.whl

tracellm/startup.py

@@ -0,0 +1,121 @@
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import httpx
+from dotenv import load_dotenv
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
+
+from tracellm.banner import render_banner
+from tracellm.mascot import MascotState, message
+from tracellm.utils import console
+
+load_dotenv()
+
+
+def _check_mongodb() -> bool:
+    try:
+        import pymongo
+        mongo_url = os.getenv("MONGO_URL")
+        if not mongo_url:
+            console.print("[yellow]MONGO_URL not set — traces won't be persisted[/yellow]")
+            return False
+        client = pymongo.MongoClient(mongo_url, serverSelectionTimeoutMS=3000)
+        client.admin.command("ping")
+        client.close()
+        return True
+    except Exception:
+        console.print("[yellow]MongoDB not reachable — traces won't be persisted[/yellow]")
+        return False
+
+
+def _start_fastapi(port: int) -> subprocess.Popen:
+    backend_dir = Path(__file__).resolve().parent.parent
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(backend_dir)
+
+    process = subprocess.Popen(
+        [sys.executable, "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", str(port), "--reload"],
+        cwd=backend_dir,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    return process
+
+
+def _health_check(port: int, timeout: int = 15) -> bool:
+    start = time.time()
+    with console.status("[bold white]Waiting for API server...[/bold white]"):
+        while time.time() - start < timeout:
+            try:
+                response = httpx.get(f"http://127.0.0.1:{port}/", timeout=3)
+                if response.status_code == 200:
+                    return True
+            except (httpx.ConnectError, httpx.TimeoutException):
+                pass
+            time.sleep(0.5)
+    return False
+
+
+def _render_status(mongodb_ok: bool, api_ok: bool, port: int, dashboard_port: int, launch_dashboard: bool) -> None:
+    table = Table.grid(padding=(0, 2))
+    table.add_column()
+    table.add_column()
+
+    table.add_row(
+        "API Server",
+        f"[green]●[/green] http://127.0.0.1:{port}" if api_ok else "[red]●[/red] Failed",
+    )
+    table.add_row(
+        "MongoDB",
+        "[green]● Connected[/green]" if mongodb_ok else "[yellow]● Skipped[/yellow]",
+    )
+    table.add_row(
+        "Dashboard",
+        f"[green]● http://localhost:{dashboard_port}[/green]" if launch_dashboard else "[dim]● Not launched[/dim]",
+    )
+    table.add_row(
+        "WebSocket",
+        f"[dim]ws://127.0.0.1:{port}/ws[/dim]",
+    )
+
+    console.print()
+    console.print(
+        Panel.fit(table, title="TraceLLM Stack", border_style="bright_black", padding=(1, 3))
+    )
+    console.print()
+
+
+def run_start(port: int = 8000, dashboard_port: int = 3000, launch_dashboard: bool = False) -> None:
+    console.print()
+    console.print(render_banner())
+    console.print()
+    console.print(message("TraceLLM starting...", MascotState.LOADING))
+    console.print()
+
+    mongodb_ok = _check_mongodb()
+    console.print(f"  [green]✓[/green] MongoDB connected" if mongodb_ok else f"  [red]✗[/red] MongoDB unavailable")
+
+    api_process = _start_fastapi(port)
+    api_ok = _health_check(port)
+    console.print(f"  [green]✓[/green] API ready" if api_ok else f"  [red]✗[/red] API failed")
+    console.print(f"  [green]✓[/green] WebSocket ready" if api_ok else f"  [red]✗[/red] WebSocket unavailable")
+
+    if launch_dashboard and api_ok:
+        import webbrowser
+        webbrowser.open(f"http://localhost:{dashboard_port}")
+
+    _render_status(mongodb_ok, api_ok, port, dashboard_port, launch_dashboard)
+
+    try:
+        api_process.wait()
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Shutting down...[/yellow]")
+        api_process.terminate()
+        api_process.wait()
+        console.print("[green]Stopped.[/green]")

tracellm/summary.py

@@ -0,0 +1,53 @@
+"""Premium trace summary card."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from tracellm.utils import render_status_badge
+
+
+def render_summary(trace_data: dict[str, Any]) -> Panel:
+    """Render a professional trace summary card."""
+    status = str(trace_data["status"])
+    badge = render_status_badge(status)
+    border = "green" if status == "success" else "yellow" if status == "warning" else "red"
+
+    table = Table.grid(padding=(0, 3))
+    table.add_column(style="bright_black", width=14)
+    table.add_column(style="white")
+
+    table.add_row("Model", str(trace_data.get("model_name", "unknown")))
+    table.add_row("Latency", f"{float(trace_data['latency']):.2f} ms")
+    table.add_row("Tokens", f"{trace_data['token_count']:,}")
+    table.add_row("Retries", str(trace_data["retry_count"]))
+    table.add_row("Status", badge)
+    created = str(trace_data.get("created_at", ""))
+    if created:
+        try:
+            from datetime import datetime
+            dt = datetime.fromisoformat(created)
+            created = dt.strftime("%Y-%m-%d %H:%M:%S")
+        except (ValueError, TypeError):
+            pass
+    table.add_row("Timestamp", created)
+    table.add_row("Trace ID", str(trace_data["trace_id"]))
+
+    return Panel(
+        table,
+        title="\U0001f996 Trace Complete",
+        border_style=border,
+        padding=(1, 3),
+    )
+
+
+def print_summary(trace_data: dict[str, Any]) -> None:
+    """Print the trace summary card to console."""
+    from tracellm.utils import console
+    console.print()
+    console.print(render_summary(trace_data))
+    console.print()

tracellm/trace_stream.py

@@ -0,0 +1,68 @@
+"""Live event stream for trace execution."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from tracellm.utils import console
+
+
+class TraceStream:
+    """Realtime event stream that renders timestamped trace events."""
+
+    def __init__(self, prompt: str, model_name: str) -> None:
+        self.prompt = prompt
+        self.model_name = model_name
+        self.events: list[tuple[str, str, str]] = []
+        self._start = datetime.now()
+        self._live = Live(console=console, refresh_per_second=10, transient=True)
+
+    def __enter__(self) -> TraceStream:
+        self.emit("trace.start")
+        self._live.__enter__()
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.emit("trace.complete")
+        self._live.__exit__(*args)
+
+    def emit(self, event: str, detail: str = "") -> None:
+        """Emit a trace event and update the live display."""
+        ts = datetime.now().strftime("%H:%M:%S")
+        self.events.append((ts, event, detail))
+        self._live.update(self._render())
+
+    def _render(self) -> Panel:
+        now = datetime.now()
+        elapsed = (now - self._start).total_seconds()
+
+        event_table = Table.grid(padding=(0, 2))
+        event_table.add_column(style="bright_black", width=10)
+        event_table.add_column(style="cyan")
+        event_table.add_column(style="dim", width=30)
+
+        for ts, evt, det in self.events:
+            event_table.add_row(f"[{ts}]", evt, det)
+
+        summary = Table.grid(padding=(0, 2))
+        summary.add_column(style="bright_black")
+        summary.add_column(style="white")
+        summary.add_row("Prompt", self.prompt[:60])
+        summary.add_row("Model", self.model_name)
+        summary.add_row("Elapsed", f"{elapsed:.1f}s")
+        summary.add_row("Events", str(len(self.events)))
+
+        body = Table.grid(padding=(0, 1))
+        body.add_column()
+        body.add_row(Text("Event Stream", style="bold white"))
+        body.add_row(event_table)
+        body.add_row(Text(""))
+        body.add_row(summary)
+
+        return Panel(body, title="Live Trace", border_style="bright_black", padding=(1, 2))