synth-ai 0.2.8.dev2__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/cli/task_apps/deploy.py

@@ -0,0 +1,7 @@
+"""Compatibility wrapper for task-app deploy command."""
+
+from __future__ import annotations
+
+from synth_ai.cli.deploy import deploy_cmd as deploy_command  # type: ignore[attr-defined]
+
+__all__ = ["deploy_command"]

synth_ai/cli/task_apps/list.py

@@ -0,0 +1,26 @@
+"""Task app list command."""
+
+from __future__ import annotations
+
+import click
+
+from synth_ai.sdk.task.apps import registry
+
+from .commands import task_app_group
+
+
+@task_app_group.command("list")
+def list_apps() -> None:
+    """List registered task apps."""
+
+    entries = registry.list()
+    if not entries:
+        click.echo("No task apps registered.")
+        return
+
+    for entry in entries:
+        aliases = f" (aliases: {', '.join(entry.aliases)})" if entry.aliases else ""
+        click.echo(f"- {entry.app_id}{aliases}: {entry.description}")
+
+
+__all__ = ["list_apps"]

synth_ai/cli/task_apps/main.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import click
+
+from synth_ai.cli.lib.apps.task_app import find_task_apps_in_cwd, validate_task_app
+from synth_ai.core.apps.common import run_ruff_check
+from synth_ai.core.paths import print_paths_formatted
+
+
+@click.command()
+@click.argument(
+    "action",
+    type=click.Choice(["check", "list"]),
+    metavar="[ACTION]"
+)
+@click.argument(
+    "path",
+    type=click.Path(path_type=Path, exists=True),
+    metavar="[PATH]",
+    required=False
+)
+def task_app_cmd(
+    action: str,
+    path: Path | None,
+) -> None:
+    try:
+        match action:
+            case "check":
+                if path is None:
+                    raise click.ClickException("PATH is required for 'check'")
+                validate_task_app(path)
+                raise SystemExit(run_ruff_check(path))
+            case "list":
+                print_paths_formatted(find_task_apps_in_cwd())
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc

synth_ai/cli/task_apps/modal_serve.py

@@ -0,0 +1,11 @@
+"""Compatibility wrapper for task-app modal-serve command."""
+
+from __future__ import annotations
+
+from synth_ai.cli.task_apps import task_app_group
+
+modal_serve_command = task_app_group.commands.get("modal-serve")
+if modal_serve_command is None:  # pragma: no cover - defensive guard
+    raise RuntimeError("Modal-serve command is not registered on task_app_group")
+
+__all__ = ["modal_serve_command"]

synth_ai/cli/task_apps/serve.py

@@ -0,0 +1,11 @@
+"""Compatibility wrapper for task-app serve command."""
+
+from __future__ import annotations
+
+from synth_ai.cli.task_apps import serve_command, task_app_group
+
+serve_task_group = task_app_group.commands.get("serve")
+if serve_task_group is None:  # pragma: no cover - defensive guard
+    raise RuntimeError("Serve command is not registered on task_app_group")
+
+__all__ = ["serve_command", "serve_task_group"]

synth_ai/cli/training/__init__.py

@@ -0,0 +1,8 @@
+"""Training CLI commands (train, train_cfg, watch).
+
+Commands for running and monitoring training jobs.
+"""
+
+__all__: list[str] = []
+
+

synth_ai/cli/training/train.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.train.core import register, train_command
+
+__all__ = ["register", "train_command"]

synth_ai/cli/training/train_cfg.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+import click
+
+from synth_ai.cli.lib.train_cfgs import find_train_cfgs_in_cwd, validate_train_cfg
+from synth_ai.core.paths import print_paths_formatted
+
+
+@click.command()
+@click.argument(
+    "action",
+    type=click.Choice(["check", "list"]),
+    metavar="[ACTION]"
+)
+@click.argument(
+    "path",
+    type=click.Path(path_type=Path, exists=True),
+    metavar="[PATH]",
+    required=False
+)
+def train_cfg_cmd(
+    action: str,
+    path: Path | None,
+) -> None:
+    try:
+        match action:
+            case "check":
+                if path is None:
+                    raise click.ClickException("PATH is required for 'check'")
+                validate_train_cfg(path)
+            case "list":
+                print_paths_formatted(find_train_cfgs_in_cwd())
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc

synth_ai/cli/{watch.py → training/watch.py}

@@ -16,6 +16,13 @@ from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 
+from synth_ai.cli._internal.storage import load_storage
+
+
+def _open_db(db_url: str):
+    create_storage, storage_config = load_storage()
+    return create_storage(storage_config(connection_string=db_url))
+
 
 class _State:
     def __init__(self):
@@ -48,9 +55,7 @@ def _format_int(value: Any) -> str:
 
 
 async def _fetch_experiments(db_url: str):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         df = await db.query_traces(
@@ -114,9 +119,7 @@ def _experiments_table(df, limit: int | None = None) -> Table:
 
 
 async def _experiment_detail(db_url: str, experiment_id: str) -> dict[str, Any]:
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         exp_df = await db.query_traces(
@@ -253,9 +256,7 @@ def register(cli):
         console = Console()
 
         async def _run():
-            from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-            db = AsyncSQLTraceManager(db_url)
+            db = _open_db(db_url)
             await db.initialize()
             try:
                 df = await db.get_model_usage(model_name=model_name)
@@ -396,9 +397,7 @@ def _parse_hours(args: list[str]) -> float | None:
 
 
 async def _usage_table(db_url: str, model_name: str | None):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         df = await db.get_model_usage(model_name=model_name)
@@ -418,9 +417,7 @@ async def _usage_table(db_url: str, model_name: str | None):
 
 
 async def _traces_table(db_url: str, limit: int):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         df = await db.query_traces("SELECT * FROM session_summary ORDER BY created_at DESC")
@@ -453,10 +450,8 @@ async def _recent_table(db_url: str, hours: float, limit: int):
     # Inline the recent query to avoid cross-module coupling
     from datetime import timedelta
 
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
     start_time = datetime.now() - timedelta(hours=hours)
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         query = """

synth_ai/cli/turso.py

@@ -0,0 +1,52 @@
+"""Backwards-compatible Turso CLI entry point.
+
+This module re-exports the infra.turso helpers so existing imports
+(`synth_ai.cli.turso`) continue to work for tests and downstream users.
+It also proxies infra functions so monkeypatching works in tests.
+"""
+
+from __future__ import annotations
+
+import synth_ai.cli.infra.turso as _infra_turso
+from synth_ai.cli.infra.turso import turso  # noqa: F401
+from synth_ai.cli.root import SQLD_VERSION, find_sqld_binary, install_sqld  # noqa: F401
+
+_get_sqld_version_inner = _infra_turso._get_sqld_version
+
+
+def _get_sqld_version(binary: str) -> str | None:  # noqa: F401
+    """Delegates to the original infra implementation (monkeypatchable)."""
+    return _get_sqld_version_inner(binary)
+
+
+def _proxy_get_sqld_version(binary: str) -> str | None:
+    # Dynamic lookup so monkeypatching synth_ai.cli.turso._get_sqld_version is honored
+    import synth_ai.cli.turso as mod
+
+    return mod._get_sqld_version(binary)
+
+
+def _proxy_find_sqld_binary() -> str | None:
+    import synth_ai.cli.turso as mod
+
+    return mod.find_sqld_binary()
+
+
+def _proxy_install_sqld():
+    import synth_ai.cli.turso as mod
+
+    return mod.install_sqld()
+
+
+# Point infra at proxies so tests that monkeypatch this module influence the CLI command.
+_infra_turso._get_sqld_version = _proxy_get_sqld_version  # type: ignore[assignment]
+_infra_turso.find_sqld_binary = _proxy_find_sqld_binary  # type: ignore[assignment]
+_infra_turso.install_sqld = _proxy_install_sqld  # type: ignore[assignment]
+
+__all__ = [
+    "turso",
+    "_get_sqld_version",
+    "find_sqld_binary",
+    "install_sqld",
+    "SQLD_VERSION",
+]

synth_ai/cli/utils/__init__.py

@@ -0,0 +1,8 @@
+"""CLI utility commands (recent, traces, queue, experiments).
+
+Utility commands for viewing and managing Synth data.
+"""
+
+__all__: list[str] = []
+
+

synth_ai/cli/utils/experiments.py

@@ -0,0 +1,235 @@
+"""CLI commands for experiment queue management."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+# Clear config cache if env vars are set (must happen before other imports)
+if os.getenv("EXPERIMENT_QUEUE_DB_PATH") or os.getenv("EXPERIMENT_QUEUE_TRAIN_CMD"):
+    from synth_ai.cli.local.experiment_queue import config as queue_config
+
+    queue_config.reset_config_cache()
+
+from synth_ai.cli.local.experiment_queue.models import ExperimentStatus
+from synth_ai.cli.local.experiment_queue.schemas import (
+    ExperimentJobSummary,
+    ExperimentSubmitRequest,
+    ExperimentSummary,
+    TrialSummary,
+)
+from synth_ai.cli.local.experiment_queue.service import (
+    cancel_experiment,
+    collect_dashboard_data,
+    create_experiment,
+    fetch_experiment,
+    list_experiments,
+)
+from synth_ai.cli.local.experiment_queue.status import (
+    experiment_jobs_table,  # type: ignore[attr-defined]
+    experiment_trials_table,  # type: ignore[attr-defined]
+    render_dashboard,  # type: ignore[attr-defined]
+)
+
+STATUS_CHOICES = [status.value for status in ExperimentStatus]
+
+
+def _load_request_payload(source: str, *, inline: bool = False) -> ExperimentSubmitRequest:
+    if inline:
+        data = json.loads(source)
+    elif source == "-":
+        data = json.load(sys.stdin)
+    else:
+        path = Path(source).expanduser()
+        if not path.exists():
+            raise click.ClickException(f"Request file not found: {path}")
+        with open(path, encoding="utf-8") as fh:
+            data = json.load(fh)
+    return ExperimentSubmitRequest.model_validate(data)
+
+
+def _parse_statuses(values: tuple[str, ...]) -> list[ExperimentStatus] | None:
+    if not values:
+        return None
+    return [ExperimentStatus(value) for value in values]
+
+
+@click.command("experiments")
+@click.option(
+    "--status",
+    "status_filter",
+    multiple=True,
+    type=click.Choice(STATUS_CHOICES),
+    help="Filter experiments by status.",
+)
+@click.option("--recent", default=5, show_default=True, help="Number of recent experiments to show.")
+@click.option("--watch", is_flag=True, help="Continuously refresh the dashboard.")
+@click.option("--json", "as_json", is_flag=True, help="Emit JSON instead of tables.")
+@click.option("--interval", default=2.0, show_default=True, help="Refresh interval for --watch.")
+def experiments_cmd(
+    status_filter: tuple[str, ...],
+    recent: int,
+    watch: bool,
+    as_json: bool,
+    interval: float,
+) -> None:
+    """Show live and recent experiment activity."""
+
+    console = Console()
+
+    def _snapshot() -> None:
+        live, recent_data = collect_dashboard_data(
+            status_filter=_parse_statuses(status_filter),
+            recent_limit=recent,
+        )
+        if as_json:
+            payload = {
+                "live": [ExperimentSummary.from_experiment(exp).model_dump(mode="json") for exp in live],
+                "recent": [ExperimentSummary.from_experiment(exp).model_dump(mode="json") for exp in recent_data],
+            }
+            click.echo(json.dumps(payload, indent=2, default=str))
+        else:
+            console.clear()
+            render_dashboard(console, live, recent_data)
+
+    if watch and not as_json:
+        while True:
+            _snapshot()
+            time.sleep(max(interval, 0.5))
+    else:
+        _snapshot()
+
+
+@click.group("experiment")
+def experiment_group() -> None:
+    """Manage experiment queue submissions."""
+
+
+@experiment_group.command("submit")
+@click.argument("request", type=str)
+@click.option("--inline", is_flag=True, help="Treat REQUEST argument as inline JSON payload.")
+def experiment_submit(request: str, inline: bool) -> None:
+    """Submit a new experiment from JSON request file."""
+
+    payload = _load_request_payload(request, inline=inline)
+    experiment = create_experiment(payload)
+    summary = ExperimentSummary.from_experiment(experiment)
+    click.echo(f"Enqueued experiment {summary.experiment_id} ({summary.name}) with {summary.job_count} jobs.")
+
+
+@experiment_group.command("list")
+@click.option(
+    "--status",
+    "status_filter",
+    multiple=True,
+    type=click.Choice(STATUS_CHOICES),
+    help="Status filter.",
+)
+@click.option("--limit", default=20, show_default=True, help="Max experiments to list.")
+@click.option("--json", "as_json", is_flag=True, help="Emit JSON output.")
+def experiment_list(
+    status_filter: tuple[str, ...],
+    limit: int,
+    as_json: bool,
+) -> None:
+    """List experiments."""
+    experiments = list_experiments(
+        status=_parse_statuses(status_filter),
+        limit=limit,
+        include_live=True,
+    )
+    if as_json:
+        payload = [ExperimentSummary.from_experiment(exp).model_dump(mode="json") for exp in experiments]
+        click.echo(json.dumps(payload, indent=2, default=str))
+        return
+
+    console = Console()
+    render_dashboard(console, experiments, [])
+
+
+def _experiment_detail_json(experiment_id: str) -> str:
+    experiment = fetch_experiment(experiment_id)
+    if not experiment:
+        raise click.ClickException(f"Experiment {experiment_id} not found.")
+    payload = ExperimentSummary.from_experiment(experiment).model_dump(mode="json")
+    payload["jobs"] = [ExperimentJobSummary.from_job(job).model_dump(mode="json") for job in experiment.jobs]
+    payload["trials"] = [TrialSummary.from_trial(trial).model_dump(mode="json") for trial in experiment.trials]
+    return json.dumps(payload, indent=2, default=str)
+
+
+def _experiment_detail_console(experiment_id: str, *, console: Console | None = None, clear: bool = False) -> None:
+    experiment = fetch_experiment(experiment_id)
+    if not experiment:
+        raise click.ClickException(f"Experiment {experiment_id} not found.")
+    console = console or Console()
+    if clear:
+        console.clear()
+    summary = ExperimentSummary.from_experiment(experiment)
+    console.rule(f"[bold]Experiment {summary.experiment_id} — {summary.name}")
+    console.print(f"Status: {summary.status.value}")
+    console.print(f"Description: {summary.description or '-'}")
+    metadata_blob = experiment.metadata_json if isinstance(experiment.metadata_json, dict) else {}
+    aggregate = metadata_blob.get("aggregate", {})
+    if aggregate:
+        console.print(f"Best Score: {aggregate.get('best_score')}")
+        console.print(f"Baseline: {aggregate.get('baseline_score')}")
+        console.print(f"Rollouts: {aggregate.get('total_rollouts')}")
+        console.print(f"Total Time: {aggregate.get('total_time')}")
+    console.print(experiment_jobs_table(experiment.jobs))
+    if experiment.trials:
+        console.print(experiment_trials_table(experiment.trials))
+    else:
+        console.print("No trials recorded yet.")
+
+
+@experiment_group.command("status")
+@click.argument("experiment_id")
+@click.option("--watch", is_flag=True, help="Continuously refresh status view.")
+@click.option("--json", "as_json", is_flag=True, help="Emit JSON payload.")
+@click.option("--interval", default=2.0, show_default=True, help="Refresh interval for --watch.")
+def experiment_status(experiment_id: str, watch: bool, as_json: bool, interval: float) -> None:
+    """Show detailed experiment status."""
+    if as_json:
+        click.echo(_experiment_detail_json(experiment_id))
+        return
+
+    if watch:
+        console = Console()
+        while True:
+            _experiment_detail_console(experiment_id, console=console, clear=True)
+            time.sleep(max(interval, 0.5))
+    else:
+        _experiment_detail_console(experiment_id)
+
+
+@experiment_group.command("results")
+@click.argument("experiment_id")
+@click.option("--json", "as_json", is_flag=True, help="Emit JSON payload.")
+def experiment_results(experiment_id: str, as_json: bool) -> None:
+    """Show aggregate results for an experiment."""
+    if as_json:
+        click.echo(_experiment_detail_json(experiment_id))
+    else:
+        _experiment_detail_console(experiment_id)
+
+
+@experiment_group.command("cancel")
+@click.argument("experiment_id")
+def experiment_cancel(experiment_id: str) -> None:
+    """Cancel an experiment and revoke in-flight jobs."""
+    experiment = cancel_experiment(experiment_id)
+    if not experiment:
+        raise click.ClickException(f"Experiment {experiment_id} not found.")
+    click.echo(f"Experiment {experiment_id} canceled.")
+
+
+def register(cli: click.Group) -> None:
+    """Register commands on the main CLI."""
+    cli.add_command(experiments_cmd)
+    cli.add_command(experiment_group)