synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/cli/infra/balance.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+CLI: check remaining credit balance from Synth backend.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+from collections.abc import Callable
+from typing import Any, cast
+
+import click
+import requests
+from requests import Response
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+
+def _load_base_url_module() -> tuple[str, Callable[[], tuple[str, str]]]:
+    try:
+        module = cast(Any, importlib.import_module("synth_ai.core.env"))
+        default = cast(str, module.PROD_BASE_URL_DEFAULT)
+        getter = cast(Callable[[], tuple[str, str]], module.get_backend_from_env)
+        return str(default), getter
+    except Exception:
+        return "https://api.usesynth.ai", lambda: ("https://api.usesynth.ai", "")
+
+
+PROD_BASE_URL_DEFAULT, _get_backend_from_env = _load_base_url_module()
+PROD_BACKEND_BASE = f"{PROD_BASE_URL_DEFAULT.rstrip('/')}/api/v1"
+
+
+def _get_default_base_url() -> str:
+    # Prefer explicit backend variables; else default to prod backend
+    for var in ("SYNTH_BACKEND_BASE_URL", "BACKEND_BASE_URL", "SYNTH_BASE_URL"):
+        val = os.getenv(var)
+        if val:
+            return val
+    base, _ = _get_backend_from_env()
+    base = base.rstrip("/")
+    if base.endswith("/api"):
+        base = base[: -len("/api")]
+    return f"{base}/api/v1"
+
+
+def _ensure_api_v1_prefix(base_url: str) -> str:
+    """Ensure the base URL includes the /api/v1 prefix.
+
+    Accepts either a full prefix (http://host:port/api/v1) or a root
+    service URL (http://host:port). If no '/api' segment is present, append
+    '/api/v1'.
+    """
+    b = base_url.rstrip("/")
+    if b.endswith("/api") or b.endswith("/api/v1") or "/api/" in b:
+        return b
+    return b + "/api/v1"
+
+
+def _resolve_api_key(explicit_key: str | None) -> tuple[str | None, str | None]:
+    if explicit_key:
+        return explicit_key, "--api-key"
+    # Try multiple env vars commonly used in this repo
+    for var in ("SYNTH_BACKEND_API_KEY", "SYNTH_API_KEY", "DEFAULT_DEV_API_KEY"):
+        val = os.getenv(var)
+        if val:
+            return val, var
+    return None, None
+
+
+def _auth_headers(api_key: str | None) -> dict[str, str]:
+    key, _ = _resolve_api_key(api_key)
+    if not key:
+        return {}
+    return {"Authorization": f"Bearer {key}"}
+
+
+def register(cli):
+    @cli.command()
+    @click.option(
+        "--base-url",
+        default=_get_default_base_url,
+        show_default=True,
+        help="Synth backend base URL (prefix like http://host:port/api/v1)",
+    )
+    @click.option(
+        "--api-key",
+        envvar="SYNTH_API_KEY",
+        help="API key for the Synth backend (or set SYNTH_API_KEY)",
+    )
+    @click.option(
+        "--usage/--no-usage",
+        default=False,
+        help="Also fetch recent usage summary",
+    )
+    def balance(base_url: str, api_key: str | None, usage: bool):
+        """Show your remaining credit balance from the Synth backend."""
+        console = Console()
+
+        key_val, key_src = _resolve_api_key(api_key)
+        if not key_val:
+            console.print("[red]Missing API key.[/red] Set via --api-key or SYNTH_API_KEY env var.")
+            return
+
+        base = _ensure_api_v1_prefix(base_url)
+
+        # No special-casing for modal.run domains; honor the provided base URL
+
+        try:
+            resp: Response = requests.get(
+                f"{base}/balance/current",
+                headers=_auth_headers(api_key),
+                timeout=10,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            cents = int(data.get("balance_cents", 0))
+            dollars = float(data.get("balance_dollars", cents / 100.0))
+            console.print(f"Balance: [bold]${dollars:,.2f}[/bold]")
+
+            # Try to print compact spend summary for 24h and 7d
+            try:
+                u: Response = requests.get(
+                    f"{base}/balance/usage/windows",
+                    params={"hours": "24,168"},
+                    headers=_auth_headers(api_key),
+                    timeout=10,
+                )
+                if u.ok:
+                    uj = u.json()
+                    rows = uj.get("windows", [])
+                    windows = {
+                        int(r.get("window_hours")): r
+                        for r in rows
+                        if isinstance(r.get("window_hours"), int)
+                    }
+
+                    def _usd(c):
+                        try:
+                            return f"${(int(c) / 100):,.2f}"
+                        except Exception:
+                            return "$0.00"
+
+                    if 24 in windows or 168 in windows:
+                        t = Table(
+                            title="Spend (Tokens vs GPU)", box=box.SIMPLE, header_style="bold"
+                        )
+                        t.add_column("Window")
+                        t.add_column("Tokens", justify="right")
+                        t.add_column("GPU", justify="right")
+                        t.add_column("Total", justify="right")
+                        for h, label in ((24, "24h"), (168, "7d")):
+                            if h in windows:
+                                w = windows[h]
+                                t.add_row(
+                                    label,
+                                    _usd(w.get("token_spend_cents", 0)),
+                                    _usd(w.get("gpu_spend_cents", 0)),
+                                    _usd(w.get("total_spend_cents", 0)),
+                                )
+                        console.print(t)
+                elif usage:
+                    # Fallback to older summary if requested explicitly
+                    u2: Response = requests.get(
+                        f"{base}/balance/usage",
+                        headers=_auth_headers(api_key),
+                        timeout=10,
+                    )
+                    if u2.ok:
+                        uj = u2.json()
+                        cm = uj.get("current_month", {})
+                        l30 = uj.get("last_30_days", {})
+                        t = Table(title="Usage Summary", box=box.SIMPLE, header_style="bold")
+                        t.add_column("Window")
+                        t.add_column("Token Spend", justify="right")
+                        t.add_column("GPU Spend", justify="right")
+                        t.add_column("Total", justify="right")
+                        t.add_row(
+                            "Current Month",
+                            f"${(cm.get('token_spend_cents', 0) / 100):,.2f}",
+                            f"${(cm.get('gpu_spend_cents', 0) / 100):,.2f}",
+                            f"${(cm.get('total_spend_cents', 0) / 100):,.2f}",
+                        )
+                        t.add_row(
+                            "Last 30 days",
+                            f"${(l30.get('token_spend_cents', 0) / 100):,.2f}",
+                            f"${(l30.get('gpu_spend_cents', 0) / 100):,.2f}",
+                            f"${(l30.get('total_spend_cents', 0) / 100):,.2f}",
+                        )
+                        console.print(t)
+            except Exception:
+                # Silent failure on usage summary
+                pass
+
+        except requests.HTTPError as e:
+            try:
+                detail = e.response.json().get("detail") if e.response else None
+            except Exception:
+                detail = None
+            if e.response is not None and e.response.status_code == 401:
+                key_dbg, key_src = _resolve_api_key(api_key)
+                shown = (key_dbg[:6] + "…" + key_dbg[-4:]) if key_dbg else "<none>"
+                console.print(
+                    "[red]Unauthorized (401).[/red] The API key was not accepted by the backend."
+                )
+                console.print(
+                    f"- Using base URL: {base}\n- API key (masked): {shown}\n- Key source: {key_src or '<none>'}\n- Ensure this key exists in the backend DB (table api_keys) and is active."
+                )
+                console.print(
+                    "If running locally, you can seed a dev key by setting ENVIRONMENT=dev and ensuring the DB has no API keys (auto-seed path), or create one via your admin path."
+                )
+            else:
+                console.print(f"[red]HTTP error:[/red] {e} {detail or ''}")
+        except Exception as e:
+            console.print(f"[red]Error:[/red] {e}")

synth_ai/cli/infra/mcp.py

@@ -0,0 +1,35 @@
+
+
+import typing
+from pathlib import Path
+
+import click
+
+from synth_ai.core.integrations.mcp.claude import ClaudeConfig
+
+Agent = typing.Literal[
+    "claude",
+]
+
+
+@click.command()
+@click.argument(
+    "agent",
+    type=click.Choice(
+        list(typing.get_args(Agent)),
+        case_sensitive=False
+    ),
+    default = "claude"
+)
+@click.option(
+    "--config-path",
+    "config_path",
+    type=Path,
+    default=None
+)
+def mcp_cmd(agent: Agent, config_path: Path | None) -> None:
+    match agent:
+        case "claude":
+            target_path = config_path or ClaudeConfig.get_default_config_path()
+            config = ClaudeConfig(target_path)
+            config.update_mcp_config()

synth_ai/cli/infra/modal_app.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import click
+
+from synth_ai.cli.lib.apps.modal_app import find_modal_apps_in_cwd, validate_modal_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 modal_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_modal_app(path)
+                raise SystemExit(run_ruff_check(path))
+            case "list":
+                print_paths_formatted(find_modal_apps_in_cwd())
+    except Exception as exc:
+        raise click.ClickException(str(exc)) from exc

synth_ai/cli/infra/setup.py

@@ -0,0 +1,69 @@
+import os
+import typing
+from typing import Literal
+
+import click
+
+from synth_ai.cli.lib.env import (
+    mask_str,
+    resolve_env_var,
+    write_env_var_to_dotenv,
+    write_env_var_to_json,
+)
+from synth_ai.core.auth import fetch_credentials_from_web_browser
+
+SourceType = Literal[
+    "web",
+    "local"
+]
+
+
+@click.command()
+@click.option(
+    "--source",
+    type=click.Choice(
+        list(typing.get_args(SourceType)),
+        case_sensitive=False
+    ),
+    default="web",
+    show_default=True,
+    help="Source for credentials: 'web' for browser authentication, 'local' for environment variables"
+)
+@click.option(
+    "--approve",
+    is_flag=True,
+    default=False,
+    help="Approve automatically opening web browser for authentication"
+)
+def setup_cmd(
+    source: SourceType = "web",
+    approve: bool = False
+) -> None:
+    credentials = {}
+    match source:
+        case "local":
+            credentials["SYNTH_API_KEY"] = resolve_env_var("SYNTH_API_KEY")
+            credentials["ENVIRONMENT_API_KEY"] = resolve_env_var("ENVIRONMENT_API_KEY")
+        case "web":
+            if not approve:
+                approve = click.confirm(
+                    "This will open your web browser for authentication. Continue?",
+                    default=True
+                )
+                if not approve:
+                    return
+            credentials = fetch_credentials_from_web_browser()
+
+    required = {
+        "SYNTH_API_KEY",
+        "ENVIRONMENT_API_KEY"
+    }
+    missing = [k for k in required if not credentials.get(k)]
+    if missing:
+        raise ValueError(f"Missing credential values: {', '.join(missing)}")
+
+    for k, v in credentials.items():
+        write_env_var_to_json(k, v, "~/.synth-ai/config.json")
+        write_env_var_to_dotenv(k, v)
+        os.environ[k] = v
+        print(f"Loaded {k}={mask_str(v)} to process environment")

synth_ai/cli/infra/status.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""Compatibility wrapper for legacy status imports."""
+
+from __future__ import annotations
+
+import click
+
+from synth_ai.cli.commands.status import register as _register_status
+
+
+def register(cli: click.Group) -> None:
+    """Register status subcommands on the provided CLI group."""
+    _register_status(cli)
+
+
+__all__ = ["register"]

synth_ai/cli/infra/turso.py

@@ -0,0 +1,77 @@
+"""Utility CLI command for managing Turso sqld binaries."""
+
+from __future__ import annotations
+
+import subprocess
+
+import click
+
+from synth_ai.cli.root import (  # type: ignore[import-untyped]
+    SQLD_VERSION,
+    find_sqld_binary,
+    install_sqld,
+)
+
+
+def register(cli: click.Group) -> None:
+    """Register the turso command on the main CLI group."""
+
+    cli.add_command(turso)
+
+
+def _get_sqld_version(binary: str) -> str | None:
+    """Return the version string reported by the sqld binary."""
+
+    try:
+        result = subprocess.run(
+            [binary, "--version"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.CalledProcessError, ValueError):
+        return None
+
+    output = result.stdout.strip() or result.stderr.strip()
+    return output or None
+
+
+@click.command()
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Reinstall the pinned sqld build even if one is already available.",
+)
+def turso(force: bool) -> None:
+    """Ensure the Turso sqld binary required for tracing v3 is installed."""
+
+    existing_path = find_sqld_binary()
+
+    if existing_path and not force:
+        version_info = _get_sqld_version(existing_path)
+        click.echo(f"✅ Turso sqld detected at {existing_path}.")
+        if version_info:
+            click.echo(f"   Reported version: {version_info}")
+        if version_info and SQLD_VERSION not in version_info:
+            click.echo(
+                f"⚠️ Pinned version is {SQLD_VERSION}. Run with --force to install the supported build."
+            )
+        else:
+            click.echo("No action taken. Use --force to reinstall the pinned build.")
+        return
+
+    if existing_path and force:
+        click.echo(f"♻️ Reinstalling Turso sqld {SQLD_VERSION} (previously at {existing_path}).")
+    else:
+        click.echo(f"📦 Installing Turso sqld {SQLD_VERSION}…")
+
+    try:
+        installed_path = install_sqld()
+    except subprocess.CalledProcessError as exc:  # pragma: no cover - surfaced as Click error
+        raise click.ClickException(
+            f"sqld installation failed (exit code {exc.returncode})."
+        ) from exc
+
+    click.echo(f"✅ sqld installed to {installed_path}")
+    click.echo("Ensure ~/.local/bin is on your PATH before running Synth AI services.")

synth_ai/cli/lib/__init__.py

@@ -0,0 +1,10 @@
+"""
+Support utilities reused across CLI subcommands.
+
+This module currently exposes helpers for env handling and discovery by
+re-exporting the maintained implementations under ``synth_ai.utils``.
+"""
+
+from __future__ import annotations
+
+from .task_app_env import *  # noqa: F401,F403

synth_ai/cli/lib/agents.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+
+AGENTS_TEXT = """
+sinf
+
+NEVER USE timeout. Do not add timeout parameters, timeout arguments, or timeout configurations to any code, API calls, or operations.
+"""
+SYNTH_DIV_START = "### --- SYNTH SECTION START ---"
+SYNTH_DIV_END = "### ---- SYNTH SECTION END ----"
+
+
+def _render_block() -> str:
+    return f"{SYNTH_DIV_START}\n{AGENTS_TEXT}\n{SYNTH_DIV_END}"
+
+
+def _append_block(prefix: str) -> str:
+    prefix = prefix.rstrip()
+    block = _render_block()
+    if prefix:
+        return f"{prefix}\n\n{block}\n"
+    return f"{block}\n"
+
+
+def write_agents_md() -> None:
+    path = Path.cwd() / "AGENTS.md"
+    if not path.exists():
+        path.write_text(_append_block(""), encoding="utf-8")
+        return
+
+    file_text = path.read_text(encoding="utf-8")
+
+    # Remove orphan end markers first (end markers without a preceding start marker)
+    cleaned = file_text
+    end_pos = cleaned.find(SYNTH_DIV_END)
+    start_pos = cleaned.find(SYNTH_DIV_START)
+    
+    # If there's an end marker before any start marker
+    if end_pos != -1 and (start_pos == -1 or end_pos < start_pos):
+        if start_pos == -1:
+            # No start markers at all - remove everything including content before orphan
+            cleaned = cleaned[end_pos + len(SYNTH_DIV_END):].lstrip()
+        else:
+            # There are start markers after the orphan - preserve content before orphan
+            before_orphan = cleaned[:end_pos].rstrip()
+            after_orphan = cleaned[end_pos + len(SYNTH_DIV_END):].lstrip()
+            cleaned = "\n\n".join(filter(None, [before_orphan, after_orphan]))
+    
+    # Find the first start and last end marker to consolidate multiple sections
+    first_start = cleaned.find(SYNTH_DIV_START)
+    last_end = cleaned.rfind(SYNTH_DIV_END)
+    
+    if first_start != -1 and last_end != -1 and last_end > first_start:
+        # We have at least one valid section, consolidate all into one
+        before = cleaned[:first_start].rstrip()
+        after = cleaned[last_end + len(SYNTH_DIV_END):].lstrip()
+        
+        parts: list[str] = []
+        if before:
+            parts.append(before)
+        parts.append(_render_block())
+        if after:
+            parts.append(after)
+        
+        new_text = "\n\n".join(parts)
+        if not new_text.endswith("\n"):
+            new_text += "\n"
+        path.write_text(new_text, encoding="utf-8")
+        return
+    
+    # No valid sections found, remove any remaining orphan markers
+    cleaned = cleaned.replace(SYNTH_DIV_END, "")
+    cleaned = cleaned.replace(AGENTS_TEXT, "")
+    cleaned = cleaned.strip()
+    if cleaned:
+        cleaned += "\n\n"
+    path.write_text(f"{cleaned}{_render_block()}\n", encoding="utf-8")

synth_ai/cli/lib/apps/modal_app.py

@@ -0,0 +1,101 @@
+import ast
+from datetime import datetime
+from pathlib import Path
+
+from synth_ai.cli.lib.prompts import ctx_print
+from synth_ai.core.apps.common import get_module, validate_py_file_compiles
+from synth_ai.core.paths import is_hidden_path, validate_file_type
+
+
+def get_app_name(call: ast.Call) -> str | None:
+    for kw in call.keywords:
+        if (
+            kw.arg in {"name", "app_name"}
+            and isinstance(kw.value, ast.Constant)
+            and isinstance(kw.value.value, str)
+        ):
+            return kw.value.value
+    if call.args:
+        first = call.args[0]
+        if isinstance(first, ast.Constant) and isinstance(first.value, str):
+            return first.value
+    return None
+
+
+def validate_app_declaration(path: Path) -> None:
+    ast_module = get_module(path)
+    app_aliases: set[str] = set()
+    modal_aliases: set[str] = set()
+    for node in ast.walk(ast_module):
+        if isinstance(node, ast.ImportFrom) and node.module == "modal":
+            for alias in node.names:
+                if alias.name == "App":
+                    app_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "modal":
+                    modal_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.Call):
+            func = node.func
+            if isinstance(func, ast.Name) and func.id in app_aliases:
+                if get_app_name(node):
+                    return None
+            elif (
+                isinstance(func, ast.Attribute)
+                and func.attr == "App"
+                and isinstance(func.value, ast.Name)
+                and func.value.id in modal_aliases
+                and get_app_name(node)
+            ):
+                return None
+    raise ValueError(f"{path} must declare `app = modal.App(...)` (or import `App` directly) with a literal name.")
+
+
+def validate_modal_app(
+    path: Path,
+    discovery: bool = False
+) -> Path:
+    def print_pass():
+        ctx_print("Check passed", not discovery)
+    
+    ctx_print("\nChecking if .py file", not discovery)
+    validate_file_type(path, ".py")
+    print_pass()
+    
+    ctx_print("\nChecking if app = modal.App(...) declaration exists", not discovery)
+    validate_app_declaration(path)
+    print_pass()
+
+    ctx_print("\nChecking if compiles", not discovery)
+    validate_py_file_compiles(path)
+    print_pass()
+    print('\n')
+
+    return path
+
+
+def find_modal_apps_in_cwd() -> list[tuple[Path, str]]:
+    cwd = Path.cwd().resolve()
+    entries: list[tuple[Path, str, float]] = []
+    for path in cwd.rglob("*.py"):
+        if is_hidden_path(path, cwd):
+            continue
+        if not path.is_file():
+            continue
+        try:
+            validate_modal_app(path, True)
+        except Exception:
+            continue
+        try:
+            rel_path = path.relative_to(cwd)
+        except ValueError:
+            rel_path = path
+        try:
+            mtime = path.stat().st_mtime
+            mtime_str = datetime.fromtimestamp(mtime).isoformat(sep=" ", timespec="seconds")
+        except OSError:
+            mtime = 0.0
+            mtime_str = ""
+        entries.append((rel_path, mtime_str, mtime))
+    entries.sort(key=lambda item: item[2], reverse=True)
+    return [(rel_path, mtime_str) for rel_path, mtime_str, _ in entries]