synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

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]