synth-ai 0.2.2.dev0__py3-none-any.whl → 0.2.3__py3-none-any.whl

synth_ai/cli/recent.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+CLI: experiments active in the last K hours with summary stats.
+"""
+
+import asyncio
+from datetime import datetime, timedelta
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+
+def _fmt_int(v) -> str:
+    try:
+        return f"{int(v):,}"
+    except Exception:
+        return "0"
+
+
+def _fmt_money(v) -> str:
+    try:
+        return f"${float(v or 0.0):.4f}"
+    except Exception:
+        return "$0.0000"
+
+
+def _fmt_time(v) -> str:
+    try:
+        return str(v)
+    except Exception:
+        return "-"
+
+
+async def _fetch_recent(db_url: str, hours: float):
+    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
+    start_time = datetime.now() - timedelta(hours=hours)
+
+    db = AsyncSQLTraceManager(db_url)
+    await db.initialize()
+    try:
+        query = """
+            WITH windowed_sessions AS (
+                SELECT *
+                FROM session_traces
+                WHERE created_at >= :start_time
+            )
+            SELECT 
+                e.experiment_id,
+                e.name,
+                e.description,
+                MIN(ws.created_at) AS window_start,
+                MAX(ws.created_at) AS window_end,
+                COUNT(DISTINCT ws.session_id) AS runs,
+                COUNT(DISTINCT ev.id) AS events,
+                COUNT(DISTINCT m.id) AS messages,
+                SUM(CASE WHEN ev.event_type = 'cais' THEN ev.cost_usd ELSE 0 END) / 100.0 AS cost_usd,
+                SUM(CASE WHEN ev.event_type = 'cais' THEN ev.total_tokens ELSE 0 END) AS tokens
+            FROM windowed_sessions ws
+            LEFT JOIN experiments e ON ws.experiment_id = e.experiment_id
+            LEFT JOIN events ev ON ws.session_id = ev.session_id
+            LEFT JOIN messages m ON ws.session_id = m.session_id
+            GROUP BY e.experiment_id, e.name, e.description
+            ORDER BY window_end DESC
+        """
+        df = await db.query_traces(query, {"start_time": start_time})
+        return df
+    finally:
+        await db.close()
+
+
+def register(cli):
+    @cli.command()
+    @click.option(
+        "--url",
+        "db_url",
+        default="sqlite+aiosqlite:///./synth_ai.db/dbs/default/data",
+        help="Database URL",
+    )
+    @click.option("--hours", default=24.0, type=float, help="Look back window in hours")
+    @click.option("--limit", default=20, type=int, help="Max experiments to display")
+    def recent(db_url: str, hours: float, limit: int):
+        """List experiments with activity in the last K hours with summary stats."""
+
+        console = Console()
+
+        async def _run():
+            df = await _fetch_recent(db_url, hours)
+
+            table = Table(title=f"Experiments in last {hours:g}h", header_style="bold", box=box.SIMPLE)
+            for col in ["Experiment", "Runs", "First", "Last", "Events", "Msgs", "Cost", "Tokens"]:
+                table.add_column(col, justify="right" if col in {"Runs","Events","Msgs","Tokens"} else "left")
+
+            if df is None or df.empty:
+                table.add_row("-", "0", "-", "-", "-", "-", "-", "-")
+            else:
+                count = 0
+                for _, r in df.iterrows():
+                    if count >= limit:
+                        break
+                    count += 1
+                    name = r.get("name") or "Unnamed"
+                    exp_disp = f"{name[:28]} [dim]({_short(r.get('experiment_id'))})[/dim]"
+                    table.add_row(
+                        exp_disp,
+                        _fmt_int(r.get("runs", 0)),
+                        _fmt_time(r.get("window_start")),
+                        _fmt_time(r.get("window_end")),
+                        _fmt_int(r.get("events", 0)),
+                        _fmt_int(r.get("messages", 0)),
+                        _fmt_money(r.get("cost_usd", 0.0)),
+                        _fmt_int(r.get("tokens", 0)),
+                    )
+
+            console.print(table)
+
+        def _short(exp_id) -> str:
+            try:
+                return str(exp_id)[:8]
+            except Exception:
+                return ""
+
+        asyncio.run(_run())

synth_ai/cli/root.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Canonical CLI entrypoint for Synth AI (moved from synth_ai/cli.py).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import time
+from typing import Optional
+
+import click
+
+
+def find_sqld_binary() -> Optional[str]:
+    sqld_path = shutil.which("sqld")
+    if sqld_path:
+        return sqld_path
+    common_paths = [
+        "/usr/local/bin/sqld",
+        "/usr/bin/sqld",
+        os.path.expanduser("~/.local/bin/sqld"),
+        os.path.expanduser("~/bin/sqld"),
+    ]
+    for path in common_paths:
+        if os.path.exists(path) and os.access(path, os.X_OK):
+            return path
+    return None
+
+
+def install_sqld() -> str:
+    click.echo("🔧 sqld not found. Installing...")
+    script = """#!/bin/bash
+set -e
+SQLD_VERSION="v0.26.2"
+OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+ARCH=$(uname -m)
+case "$ARCH" in
+  x86_64) ARCH="x86_64" ;;
+  aarch64|arm64) ARCH="aarch64" ;;
+  *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
+esac
+URL="https://github.com/tursodatabase/libsql/releases/download/libsql-server-${SQLD_VERSION}/sqld-${OS}-${ARCH}.tar.xz"
+TMP_DIR=$(mktemp -d)
+cd "$TMP_DIR"
+curl -L -o sqld.tar.xz "$URL"
+tar -xf sqld.tar.xz
+mkdir -p ~/.local/bin
+mv sqld ~/.local/bin/
+chmod +x ~/.local/bin/sqld
+cd -
+rm -rf "$TMP_DIR"
+"""
+    path = "/tmp/install_sqld.sh"
+    with open(path, "w") as f:
+        f.write(script)
+    subprocess.run(["bash", path], check=True)
+    os.unlink(path)
+    local_bin = os.path.expanduser("~/.local/bin")
+    if local_bin not in os.environ.get("PATH", ""):
+        os.environ["PATH"] = f"{local_bin}:{os.environ.get('PATH', '')}"
+    return os.path.expanduser("~/.local/bin/sqld")
+
+
+@click.group()
+def cli():
+    """Synth AI - Software for aiding the best and multiplying the will."""
+
+
+@cli.command()
+@click.option("--db-file", default="traces/v3/synth_ai.db", help="Database file path")
+@click.option("--sqld-port", default=8080, type=int, help="Port for sqld HTTP interface")
+@click.option("--env-port", default=8901, type=int, help="Port for environment service")
+@click.option("--no-sqld", is_flag=True, help="Skip starting sqld daemon")
+@click.option("--no-env", is_flag=True, help="Skip starting environment service")
+@click.option("--reload/--no-reload", default=False, help="Enable auto-reload (default: off). Or set SYNTH_RELOAD=1")
+@click.option("--force/--no-force", default=True, help="Kill any process already bound to --env-port without prompting")
+def serve(db_file: str, sqld_port: int, env_port: int, no_sqld: bool, no_env: bool, reload: bool, force: bool):
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    processes = []
+
+    def signal_handler(sig, frame):
+        click.echo("\n🛑 Shutting down services...")
+        for proc in processes:
+            if proc.poll() is None:
+                proc.terminate()
+                try:
+                    proc.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    proc.kill()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    if not no_sqld:
+        try:
+            result = subprocess.run(["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"], capture_output=True, text=True)
+            if result.returncode != 0:
+                sqld_bin = find_sqld_binary() or install_sqld()
+                click.echo(f"🗄️  Starting sqld (local only) on port {sqld_port}")
+                proc = subprocess.Popen([sqld_bin, "--db-path", db_file, "--http-listen-addr", f"127.0.0.1:{sqld_port}"], stdout=open("sqld.log", "w"), stderr=subprocess.STDOUT)
+                processes.append(proc)
+                time.sleep(2)
+        except FileNotFoundError:
+            pass
+
+    if not no_env:
+        click.echo("")
+        click.echo(f"🚀 Starting Synth-AI Environment Service on port {env_port}")
+        click.echo("")
+
+        # Ensure port is free
+        try:
+            import socket
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                in_use = s.connect_ex(("127.0.0.1", env_port)) == 0
+        except Exception:
+            in_use = False
+        if in_use:
+            pids: list[str] = []
+            try:
+                out = subprocess.run(["lsof", "-ti", f":{env_port}"], capture_output=True, text=True)
+                if out.returncode == 0 and out.stdout.strip():
+                    pids = [p for p in out.stdout.strip().splitlines() if p]
+            except FileNotFoundError:
+                pids = []
+            if force:
+                if pids:
+                    subprocess.run(["kill", "-9", *pids], check=False)
+                    time.sleep(0.5)
+            else:
+                suffix = f" PIDs: {', '.join(pids)}" if pids else ""
+                if click.confirm(f"⚠️  Port {env_port} is in use.{suffix} Kill and continue?", default=True):
+                    if pids:
+                        subprocess.run(["kill", "-9", *pids], check=False)
+                        time.sleep(0.5)
+                else:
+                    click.echo("❌ Aborting.")
+                    sys.exit(1)
+
+        env = os.environ.copy()
+        env["SYNTH_LOGGING"] = "true"
+        click.echo("📦 Environment:")
+        click.echo(f"   Python: {sys.executable}")
+        click.echo(f"   Working directory: {os.getcwd()}")
+        click.echo("")
+        click.echo("🔄 Starting services...")
+        click.echo(f"   - sqld daemon: http://127.0.0.1:{sqld_port}")
+        click.echo(f"   - Environment service: http://127.0.0.1:{env_port}")
+        click.echo("")
+        click.echo("💡 Tips:")
+        click.echo("   - Check sqld.log if database issues occur")
+        click.echo("   - Use Ctrl+C to stop all services")
+        reload_enabled = reload or (os.getenv("SYNTH_RELOAD", "0") == "1")
+        click.echo("   - Auto-reload ENABLED (code changes restart service)" if reload_enabled else "   - Auto-reload DISABLED (stable in-memory sessions)")
+        click.echo("")
+
+        uvicorn_cmd = [
+            sys.executable, "-m", "uvicorn", "synth_ai.environments.service.app:app",
+            "--host", "0.0.0.0", "--port", str(env_port), "--log-level", "info",
+        ]
+        if reload_enabled:
+            uvicorn_cmd.append("--reload")
+            if os.path.exists("synth_ai"):
+                uvicorn_cmd.extend(["--reload-dir", "synth_ai"])
+        proc = subprocess.Popen(uvicorn_cmd, env=env)
+        processes.append(proc)
+
+    if processes:
+        click.echo("\n✨ All services started! Press Ctrl+C to stop.")
+        try:
+            for proc in processes:
+                proc.wait()
+        except KeyboardInterrupt:
+            pass
+    else:
+        click.echo("No services to start.")
+

synth_ai/cli/status.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+CLI: status of agent runs/versions and environment service.
+"""
+
+import asyncio
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+import requests
+
+
+async def _db_stats(db_url: str) -> dict:
+    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
+    db = AsyncSQLTraceManager(db_url)
+    await db.initialize()
+    try:
+        out: dict = {}
+        # Totals
+        totals = await db.query_traces(
+            """
+            SELECT 
+              (SELECT COUNT(*) FROM session_traces) AS sessions,
+              (SELECT COUNT(*) FROM experiments) AS experiments,
+              (SELECT COUNT(*) FROM events) AS events,
+              (SELECT COUNT(*) FROM messages) AS messages,
+              (SELECT COALESCE(SUM(CASE WHEN event_type='cais' THEN cost_usd ELSE 0 END),0)/100.0 FROM events) AS total_cost_usd,
+              (SELECT COALESCE(SUM(CASE WHEN event_type='cais' THEN total_tokens ELSE 0 END),0) FROM events) AS total_tokens
+        """
+        )
+        if not totals.empty:
+            out["totals"] = totals.iloc[0].to_dict()
+        else:
+            out["totals"] = {}
+
+        # Systems summary
+        systems = await db.query_traces(
+            """
+            SELECT system_type, COUNT(*) as count FROM systems GROUP BY system_type
+        """
+        )
+        out["systems"] = systems
+
+        versions = await db.query_traces(
+            """
+            SELECT COUNT(*) as version_count FROM system_versions
+        """
+        )
+        if not versions.empty:
+            out["version_count"] = int(versions.iloc[0]["version_count"]) 
+        else:
+            out["version_count"] = 0
+        return out
+    finally:
+        await db.close()
+
+
+def register(cli):
+    @cli.command()
+    @click.option(
+        "--url",
+        "db_url",
+        default="sqlite+aiosqlite:///./synth_ai.db/dbs/default/data",
+        help="Database URL",
+    )
+    @click.option("--service-url", default="http://127.0.0.1:8901", help="Environment service URL")
+    def status(db_url: str, service_url: str):
+        """Show DB stats, agent/environment system counts, and env service health."""
+        console = Console()
+
+        async def _run():
+            # DB
+            stats = await _db_stats(db_url)
+
+            # Env service
+            health_text = "[red]unreachable[/red]"
+            envs_list = []
+            try:
+                r = requests.get(f"{service_url}/health", timeout=2)
+                if r.ok:
+                    data = r.json()
+                    health_text = "[green]ok[/green]"
+                    envs_list = data.get("supported_environments", [])
+                else:
+                    health_text = f"[red]{r.status_code}[/red]"
+            except Exception:
+                pass
+
+            # Render
+            totals = stats.get("totals", {})
+            lines = []
+            lines.append(f"DB: [dim]{db_url}[/dim]")
+            lines.append(
+                f"Experiments: {int(totals.get('experiments', 0)):,}  "
+                f"Sessions: {int(totals.get('sessions', 0)):,}  "
+                f"Events: {int(totals.get('events', 0)):,}  "
+                f"Messages: {int(totals.get('messages', 0)):,}"
+            )
+            lines.append(
+                f"Cost: ${float(totals.get('total_cost_usd', 0.0) or 0.0):.4f}  "
+                f"Tokens: {int(totals.get('total_tokens', 0)):,}"
+            )
+            lines.append("")
+            lines.append(f"Env Service: {health_text}  [dim]{service_url}[/dim]")
+            if envs_list:
+                lines.append("Environments: " + ", ".join(sorted(envs_list)[:10]) + (" ..." if len(envs_list) > 10 else ""))
+
+            panel_main = Panel("\n".join(lines), title="Synth AI Status", border_style="cyan")
+            console.print(panel_main)
+
+            # Systems table
+            sys_df = stats.get("systems")
+            if sys_df is not None and not sys_df.empty:
+                tbl = Table(title=f"Systems (versions: {stats.get('version_count', 0)})", box=box.SIMPLE, header_style="bold")
+                tbl.add_column("Type")
+                tbl.add_column("Count", justify="right")
+                for _, r in sys_df.iterrows():
+                    tbl.add_row(str(r.get("system_type", "-")), f"{int(r.get('count', 0)):,}")
+                console.print(tbl)
+
+        asyncio.run(_run())

synth_ai/cli/traces.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+CLI: basic info about traces (runs).
+"""
+
+import os
+import asyncio
+from typing import Optional, Dict, Tuple, List
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+
+def register(cli):
+    @cli.command()
+    @click.option(
+        "--url",
+        "db_url",
+        default="sqlite+aiosqlite:///./synth_ai.db/dbs/default/data",
+        help="Database URL",
+    )
+    @click.option("--limit", default=25, type=int, help="Max sessions to display")
+    def traces(db_url: str, limit: int):
+        """Show local trace DBs, traces per DB, and per-system counts."""
+        console = Console()
+
+        async def _run():
+            from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
+            # Discover DBs under ./synth_ai.db/dbs (or override via env)
+            root = os.getenv("SYNTH_TRACES_ROOT", "./synth_ai.db/dbs")
+            if not os.path.isdir(root):
+                console.print(f"[red]No DB root found:[/red] {root}")
+                return
+
+            entries: List[Tuple[str, str]] = []
+            for name in sorted(os.listdir(root)):
+                path = os.path.join(root, name)
+                data_path = os.path.join(path, "data")
+                if os.path.isdir(path) and os.path.isfile(data_path):
+                    entries.append((name, os.path.abspath(path)))
+
+            if not entries:
+                console.print("[dim]No trace databases found.[/dim]")
+                return
+
+            def _dir_size_bytes(dir_path: str) -> int:
+                total = 0
+                for dp, _, files in os.walk(dir_path):
+                    for fn in files:
+                        fp = os.path.join(dp, fn)
+                        try:
+                            total += os.path.getsize(fp)
+                        except OSError:
+                            pass
+                return total
+
+            async def db_counts(db_dir: str) -> Tuple[int, Dict[str, int], int, Optional[str], int]:
+                data_file = os.path.join(db_dir, "data")
+                mgr = AsyncSQLTraceManager(f"sqlite+aiosqlite:///{data_file}")
+                await mgr.initialize()
+                try:
+                    traces_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM session_traces")
+                    traces_count = int(traces_df.iloc[0]["c"]) if traces_df is not None and not traces_df.empty else 0
+                    try:
+                        systems_df = await mgr.query_traces(
+                            "SELECT system_type, COUNT(*) AS c FROM systems GROUP BY system_type"
+                        )
+                        system_counts = {
+                            str(r["system_type"] or "-"): int(r["c"] or 0)
+                            for _, r in (systems_df or []).iterrows()
+                        } if systems_df is not None and not systems_df.empty else {}
+                    except Exception:
+                        system_counts = {}
+                    try:
+                        exps_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM experiments")
+                        exps_count = int(exps_df.iloc[0]["c"]) if exps_df is not None and not exps_df.empty else 0
+                    except Exception:
+                        exps_count = 0
+                    try:
+                        last_df = await mgr.query_traces("SELECT MAX(created_at) AS last_created_at FROM session_traces")
+                        last_created = (
+                            str(last_df.iloc[0]["last_created_at"]) if last_df is not None and not last_df.empty else None
+                        )
+                    except Exception:
+                        last_created = None
+                    size_bytes = _dir_size_bytes(db_dir)
+                    return traces_count, system_counts, exps_count, last_created, size_bytes
+                finally:
+                    await mgr.close()
+
+            results = []
+            for name, db_dir in entries:
+                try:
+                    counts = await db_counts(db_dir)
+                except Exception:
+                    counts = (0, {}, 0, None, 0)
+                results.append((name, counts))
+
+            # DB summary table
+            summary = Table(title="Trace Databases", box=box.SIMPLE, header_style="bold")
+            for col in ["DB", "Traces", "Experiments", "Last Activity", "Size (GB)"]:
+                summary.add_column(col, justify="right" if col in {"Traces", "Experiments"} else "left")
+
+            aggregate_systems: Dict[str, int] = {}
+            total_bytes = 0
+            for name, (traces_count, system_counts, experiments_count, last_created_at, size_bytes) in results:
+                total_bytes += int(size_bytes or 0)
+                gb = (int(size_bytes or 0) / (1024**3))
+                summary.add_row(
+                    name,
+                    f"{traces_count:,}",
+                    f"{experiments_count:,}",
+                    str(last_created_at or "-"),
+                    f"{gb:.2f}",
+                )
+                for k, v in system_counts.items():
+                    aggregate_systems[k] = aggregate_systems.get(k, 0) + int(v)
+            console.print(summary)
+
+            # Total storage line
+            total_gb = total_bytes / (1024**3)
+            console.print(f"[dim]Total storage across DBs:[/dim] [bold]{total_gb:.2f} GB[/bold]")
+
+            # Per-system aggregate across DBs
+            if aggregate_systems:
+                st = Table(title="Per-System (all DBs)", box=box.SIMPLE, header_style="bold")
+                st.add_column("System")
+                st.add_column("Count", justify="right")
+                for sys_name, count in sorted(aggregate_systems.items(), key=lambda x: (-x[1], x[0])):
+                    st.add_row(sys_name or "-", f"{int(count):,}")
+                console.print(st)
+
+        asyncio.run(_run())