monkeybot-cli 0.2.1__py3-none-any.whl

monkeybot_cli/realtime/talk_ui.py

@@ -0,0 +1,243 @@
+"""Wire ``monkeybot talk`` (text or audio) through the shared Chat TUI / plain renderer."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import signal
+import subprocess
+import sys
+import tempfile
+import urllib.parse
+import uuid
+from pathlib import Path
+from typing import Any, NamedTuple, TextIO
+
+from monkeybot_cli.chat_tui import is_exit_command, run_chat_tui
+from monkeybot_cli.commands.chat import (
+    _DIM,
+    _RESET,
+    _USER_PROMPT,
+    _PlainRenderer,
+    _read_line,
+    use_textual_tui,
+)
+from monkeybot_cli.config_resolve import (
+    load_agent_dotenv,
+    load_config_doc,
+    resolve_agent_root,
+    resolve_config,
+)
+from monkeybot_cli.gateway_health import health_ok, wait_for_health
+from monkeybot_cli.realtime.session_controller import RealtimeSessionController
+from monkeybot_cli.runtime_python import (
+    COMBINED_GATEWAY_MODULE,
+    DEFAULT_PORT,
+    gateway_argv,
+    resolve_runtime_python,
+)
+
+
+class _SpawnedGateway(NamedTuple):
+    proc: subprocess.Popen[str]
+    log_path: Path
+    log_file: TextIO
+
+
+def _ws_to_http_base(gateway_url: str) -> str:
+    parsed = urllib.parse.urlparse(gateway_url)
+    host = parsed.hostname or "127.0.0.1"
+    port = parsed.port or DEFAULT_PORT
+    scheme = "https" if parsed.scheme == "wss" else "http"
+    return f"{scheme}://{host}:{port}"
+
+
+def _model_fields(config_path: Path | None) -> tuple[str, str]:
+    provider, model = "?", "?"
+    if config_path is None:
+        return provider, model
+    _, doc = load_config_doc(str(config_path))
+    model_cfg = doc.get("model") if isinstance(doc.get("model"), dict) else {}
+    provider = str(model_cfg.get("provider") or provider).strip() or provider
+    model = str(model_cfg.get("name") or model).strip() or model
+    return provider, model
+
+
+def _url_is_local(url: str) -> bool:
+    host = (urllib.parse.urlparse(url).hostname or "").lower()
+    return host in {"localhost", "127.0.0.1", "::1"}
+
+
+def _spawn_combined_gateway(
+    config_path: Path | None, agent_root: Path, port: int
+) -> _SpawnedGateway:
+    import os
+
+    env = os.environ.copy()
+    if config_path is not None:
+        env["MONKEYBOT_CONFIG"] = str(config_path)
+    env["PORT"] = str(port)
+    env.setdefault("LOG_LEVEL", "error")
+    log_file = tempfile.NamedTemporaryFile(
+        mode="w+",
+        prefix="monkeybot-gateway-",
+        suffix=".log",
+        delete=False,
+        encoding="utf-8",
+        errors="replace",
+    )
+    proc = subprocess.Popen(
+        gateway_argv(resolve_runtime_python(agent_root), module=COMBINED_GATEWAY_MODULE),
+        env=env,
+        cwd=agent_root,
+        stdout=subprocess.DEVNULL,
+        stderr=log_file,
+    )
+    return _SpawnedGateway(proc=proc, log_path=Path(log_file.name), log_file=log_file)
+
+
+def _cleanup_gateway(spawned: _SpawnedGateway | None) -> None:
+    if spawned is None:
+        return
+    if spawned.proc.poll() is None:
+        spawned.proc.kill()
+        with contextlib.suppress(subprocess.TimeoutExpired):
+            spawned.proc.wait(timeout=1)
+    with contextlib.suppress(OSError):
+        if not spawned.log_file.closed:
+            spawned.log_file.close()
+    with contextlib.suppress(OSError):
+        spawned.log_path.unlink(missing_ok=True)
+
+
+async def _plain_talk_session(
+    *,
+    controller: RealtimeSessionController,
+    spawned_gateway: bool,
+) -> int:
+    interrupt = asyncio.Event()
+    loop = asyncio.get_running_loop()
+    with contextlib.suppress(NotImplementedError):
+        loop.add_signal_handler(signal.SIGINT, interrupt.set)
+
+    renderer = _PlainRenderer(animations_enabled=True)
+    renderer.start_io_worker()
+    controller.set_emit(lambda e: renderer.on_event(e, controller))
+
+    try:
+        await controller.connect()
+    except RuntimeError as exc:
+        print(str(exc), file=sys.stderr)
+        await renderer.stop_io_worker()
+        return 1
+
+    hint = "Type /bye to exit"
+    if spawned_gateway:
+        hint += " (stops the gateway)"
+    print(f"{_DIM}{hint}. Ctrl-C also exits.{_RESET}\n")
+
+    try:
+        while not interrupt.is_set() and controller.stream_alive:
+            user_line = await _read_line(_USER_PROMPT, interrupt)
+            if user_line is None or interrupt.is_set():
+                break
+            if not user_line.strip():
+                continue
+            if is_exit_command(user_line):
+                if spawned_gateway:
+                    print(f"\n{_DIM}Goodbye — shutting down gateway…{_RESET}")
+                else:
+                    print(f"\n{_DIM}Goodbye.{_RESET}")
+                break
+            await controller.submit(user_line)
+    finally:
+        await controller.close()
+        await renderer.stop_io_worker()
+    return 1 if controller.stream_error else 0
+
+
+def run_talk_ui_session(
+    *,
+    gateway_url: str,
+    session_id: str | None = None,
+    start_gateway: bool = True,
+    verbose: bool = False,
+    audio_enabled: bool = False,
+    audio_recorder: Any | None = None,
+    audio_player: Any | None = None,
+    push_to_talk: Any | None = None,
+) -> int:
+    """Run talk via ChatApp (TTY) or plain renderer, with optional audio I/O."""
+    cwd = Path.cwd()
+    config_path = resolve_config(None, cwd=cwd)
+    load_agent_dotenv(cwd=cwd, config_path=config_path)
+    agent_root = resolve_agent_root(cwd=cwd, config_path=config_path)
+    provider, model = _model_fields(config_path)
+    base = _ws_to_http_base(gateway_url)
+    sid = session_id or uuid.uuid4().hex
+    parsed = urllib.parse.urlparse(gateway_url)
+    port = parsed.port or DEFAULT_PORT
+
+    spawned: _SpawnedGateway | None = None
+    if start_gateway and _url_is_local(gateway_url):
+        if not health_ok(base):
+            if config_path is None:
+                print(
+                    "Could not find monkeybot_config/monkeybot.yaml to start the gateway. "
+                    "Run the command from a MonkeyBot workspace or start the gateway manually.",
+                    file=sys.stderr,
+                )
+                return 1
+            spawned = _spawn_combined_gateway(config_path, agent_root, port)
+            if not wait_for_health(base, spawned.proc):
+                print("Gateway failed to start.", file=sys.stderr)
+                _cleanup_gateway(spawned)
+                return 1
+
+    controller = RealtimeSessionController(
+        gateway_url=gateway_url,
+        session_id=sid,
+        verbose=verbose,
+        audio_enabled=audio_enabled,
+        audio_recorder=audio_recorder,
+        audio_player=audio_player,
+        push_to_talk=push_to_talk,
+    )
+
+    try:
+        if use_textual_tui():
+            return run_chat_tui(
+                base=base,
+                agent_root=agent_root,
+                provider=provider,
+                model=model,
+                spawned_gateway=spawned is not None,
+                verbose=verbose,
+                controller=controller,
+            )
+        return asyncio.run(
+            _plain_talk_session(controller=controller, spawned_gateway=spawned is not None)
+        )
+    except KeyboardInterrupt:
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+        return 130
+    finally:
+        _cleanup_gateway(spawned)
+
+
+def run_talk_text_session(
+    *,
+    gateway_url: str,
+    session_id: str | None = None,
+    start_gateway: bool = True,
+    verbose: bool = False,
+) -> int:
+    """Backward-compatible text-only entry."""
+    return run_talk_ui_session(
+        gateway_url=gateway_url,
+        session_id=session_id,
+        start_gateway=start_gateway,
+        verbose=verbose,
+        audio_enabled=False,
+    )

monkeybot_cli/realtime/wire_encode.py

@@ -0,0 +1,39 @@
+"""Encode client realtime frames to JSON for the WebSocket wire."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from monkeybot.gateway.realtime.wire import (
+    ClientCloseFrame,
+    ClientElicitationResponseFrame,
+    ClientTextFrame,
+    ClientToolConfirmationResponseFrame,
+)
+
+
+def encode_client_frame(frame: Any) -> str:
+    """Encode a client control frame to JSON text."""
+    payload: dict[str, Any] = {"kind": frame.kind}
+    if isinstance(frame, ClientCloseFrame):
+        payload["reason"] = frame.reason
+    elif isinstance(frame, ClientTextFrame):
+        payload["text"] = frame.text
+    elif isinstance(frame, ClientToolConfirmationResponseFrame):
+        payload.update(
+            {
+                "tool_call_id": frame.tool_call_id,
+                "approved": frame.approved,
+                "reason": frame.reason,
+            }
+        )
+    elif isinstance(frame, ClientElicitationResponseFrame):
+        payload.update(
+            {
+                "elicitation_id": frame.elicitation_id,
+                "user_data": frame.user_data,
+                "cancelled": frame.cancelled,
+            }
+        )
+    return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))

monkeybot_cli/runtime_python.py

@@ -0,0 +1,91 @@
+"""Resolve the Python interpreter that should run the gateway.
+
+The CLI is intentionally thin: it depends only on base ``monkeybot`` and does **not**
+pull in provider/storage extras (``bedrock``, ``postgres``, …). Those extras are
+declared on the *agent project* (e.g. ``pr-review-agent/pyproject.toml`` lists
+``monkeybot[bedrock,postgres]``). To honor that, the gateway must be spawned from
+the agent project's interpreter rather than the CLI's own ``sys.executable``.
+
+Resolution order for an agent root:
+
+1. ``<root>/.venv/bin/python`` (or the Windows variant) — direct, no subprocess overhead.
+2. ``uv run python`` — when ``<root>/pyproject.toml`` exists but no ``.venv``.
+3. ``sys.executable`` — legacy / config-only trees (just ``monkeybot_config/``, no
+   ``pyproject.toml``). In this case extras must be installed in the CLI env.
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_PORT = 8080
+SSE_GATEWAY_MODULE = "monkeybot.gateway.main"
+COMBINED_GATEWAY_MODULE = "monkeybot.gateway.realtime_main"
+
+
+def _venv_python(agent_root: Path) -> Path | None:
+    """Return the project venv interpreter if it exists, else ``None``."""
+    venv = agent_root / ".venv"
+    for candidate in (venv / "bin" / "python", venv / "Scripts" / "python.exe"):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+@dataclass(frozen=True)
+class RuntimePython:
+    """Resolved Python runtime for an agent project.
+
+    ``argv`` is the prefix to prepend to ``-m monkeybot.gateway.*`` or
+    ``-c "…"`` doctor probes. ``source`` is for diagnostics/remediation text.
+    ``agent_root`` is set for ``uv run`` resolution (probes need the project cwd).
+    """
+
+    argv: list[str]
+    source: str  # "venv" | "uv" | "cli"
+    agent_root: Path | None = None
+
+
+def resolve_runtime_python(agent_root: Path) -> RuntimePython:
+    """Resolve the interpreter that should run the gateway for ``agent_root``."""
+    venv_py = _venv_python(agent_root)
+    if venv_py is not None:
+        return RuntimePython([str(venv_py)], "venv", agent_root)
+    if (agent_root / "pyproject.toml").is_file():
+        return RuntimePython(["uv", "run", "python"], "uv", agent_root)
+    return RuntimePython([sys.executable], "cli", agent_root)
+
+
+def gateway_argv(
+    runtime: RuntimePython,
+    *,
+    module: str = COMBINED_GATEWAY_MODULE,
+) -> list[str]:
+    """Full argv to launch a gateway module under ``runtime``.
+
+    CLI auto-start defaults to the combined SSE+WebSocket entrypoint
+    (``realtime_main``) so ``chat`` and ``talk`` share one process/port.
+    """
+    return [*runtime.argv, "-m", module]
+
+
+def run_probe(runtime: RuntimePython, code: str, *, timeout: float = 15.0) -> bool:
+    """Run ``python -c code`` under ``runtime`` and return True on exit 0.
+
+    Used by ``doctor`` to verify extras/imports in the *gateway* interpreter
+    rather than the CLI's own process.
+    """
+    import subprocess
+
+    kwargs: dict[str, object] = {}
+    if runtime.source == "uv" and runtime.agent_root is not None:
+        kwargs["cwd"] = str(runtime.agent_root)
+    proc = subprocess.run(
+        [*runtime.argv, "-c", code],
+        capture_output=True,
+        timeout=timeout,
+        **kwargs,
+    )
+    return proc.returncode == 0

monkeybot_cli/scaffold.py

@@ -0,0 +1,287 @@
+"""Workspace scaffolding from CLI-packaged ``scaffold_defaults``."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import stat
+from importlib import resources
+from importlib.resources.abc import Traversable
+from pathlib import Path
+from typing import Final
+
+import yaml
+
+from monkeybot_cli.compat import COMPATIBLE_CORE_RANGE
+from monkeybot_cli.extras_catalog import normalize_extra_token, provider_extra_name
+
+_DEFAULTS_PKG: Final = "monkeybot_cli.scaffold_defaults"
+# Matches packaged monkeybot.example.yaml default when ``--provider`` is omitted.
+_DEFAULT_PROVIDER: Final = "gemini"
+
+# (filename in packaged defaults, output name under <dest>/monkeybot_config/)
+_CONFIG_BUNDLE: Final[tuple[tuple[str, str], ...]] = (
+    ("monkeybot.example.yaml", "monkeybot.example.yaml"),
+    ("mcp.json", "mcp.json"),
+    ("command_allowlist.yaml", "command_allowlist.yaml"),
+    ("permissions.yaml", "permissions.yaml"),
+    ("AGENT.md", "AGENT.md"),
+    ("env.example", "env.example"),
+    ("otel-collector.example.yaml", "otel-collector.example.yaml"),
+)
+
+_MEMORY_INDEX: Final = (
+    "# Memory index\n\nAdd sections here or let memory tools populate this file.\n"
+)
+
+
+def _install_file(dest: Path, src: Traversable, *, force: bool) -> str:
+    # ponytail: read_bytes() avoids resources.as_file() temp-file lifetime issue in zip distributions
+    if dest.exists() and not force:
+        return "skipped"
+    existed = dest.exists()
+    dest.write_bytes(src.read_bytes())
+    return "overwritten" if existed else "created"
+
+
+def install_config_bundle(cfg_dir: Path, *, force: bool) -> list[str]:
+    """Copy packaged defaults into ``cfg_dir``; return report lines."""
+    cfg_dir.mkdir(parents=True, exist_ok=True)
+    lines: list[str] = []
+    for src_name, dest_name in _CONFIG_BUNDLE:
+        status = _install_file(
+            cfg_dir / dest_name,
+            resources.files(_DEFAULTS_PKG) / src_name,
+            force=force,
+        )
+        lines.append(f"  monkeybot_config/{dest_name}: {status}")
+    return lines
+
+
+def write_active_config(
+    cfg_dir: Path,
+    *,
+    provider: str | None = None,
+    model: str | None = None,
+    force: bool = False,
+) -> str:
+    """Create or update ``monkeybot.yaml`` from the packaged example."""
+    active = cfg_dir / "monkeybot.yaml"
+    if active.exists() and not force:
+        if provider or model:
+            doc = yaml.safe_load(active.read_text(encoding="utf-8")) or {}
+            if not isinstance(doc, dict):
+                doc = {}
+            model_sec = doc.setdefault("model", {})
+            if isinstance(model_sec, dict):
+                if provider:
+                    model_sec["provider"] = provider
+                if model:
+                    model_sec["name"] = model
+            active.write_text(yaml.safe_dump(doc, sort_keys=False), encoding="utf-8")
+            return "updated (provider/model)"
+        return "skipped"
+    existed = active.exists()
+    example_text = (resources.files(_DEFAULTS_PKG) / "monkeybot.example.yaml").read_text(
+        encoding="utf-8"
+    )
+    active.write_text(example_text, encoding="utf-8")
+    if provider or model:
+        doc = yaml.safe_load(active.read_text(encoding="utf-8")) or {}
+        if isinstance(doc, dict):
+            model_sec = doc.setdefault("model", {})
+            if isinstance(model_sec, dict):
+                if provider:
+                    model_sec["provider"] = provider
+                if model:
+                    model_sec["name"] = model
+            active.write_text(yaml.safe_dump(doc, sort_keys=False), encoding="utf-8")
+    if existed:
+        return "overwritten"
+    if provider or model:
+        return "created"
+    return "created (from monkeybot.example.yaml)"
+
+
+def ensure_memory(dest: Path, *, force: bool) -> list[str]:
+    memory = dest / "data" / "memory"
+    memory.mkdir(parents=True, exist_ok=True)
+    idx = memory / "INDEX.md"
+    if not idx.exists() or force:
+        existed = idx.exists()
+        idx.write_text(_MEMORY_INDEX, encoding="utf-8")
+        return [f"  data/memory/INDEX.md: {'overwritten' if existed else 'created'}"]
+    return ["  data/memory/INDEX.md: skipped"]
+
+
+def ensure_workspace(dest: Path, *, force: bool) -> list[str]:
+    """Create workspace/ sandbox and workspace/skills -> ../skills symlink."""
+    lines: list[str] = []
+    workspace = dest / "workspace"
+    workspace.mkdir(parents=True, exist_ok=True)
+    gitkeep = workspace / ".gitkeep"
+    if not gitkeep.exists() or force:
+        gitkeep.touch(exist_ok=True)
+        lines.append(
+            f"  workspace/.gitkeep: {'overwritten' if force and gitkeep.exists() else 'created'}"
+        )
+    else:
+        lines.append("  workspace/.gitkeep: skipped")
+
+    dest.joinpath("skills").mkdir(parents=True, exist_ok=True)
+    link = workspace / "skills"
+    expected = (dest / "skills").resolve()
+
+    if link.is_symlink():
+        if link.resolve() == expected:
+            lines.append("  workspace/skills: skipped (symlink ok)")
+            return lines
+        link.unlink()
+
+    if link.exists() and not link.is_symlink():
+        if not force:
+            lines.append("  workspace/skills: skipped (path exists)")
+            return lines
+        if link.is_dir():
+            shutil.rmtree(link)
+        else:
+            link.unlink()
+
+    try:
+        link.symlink_to("../skills", target_is_directory=True)
+        lines.append("  workspace/skills: symlink -> ../skills")
+    except OSError:
+        readme = workspace / "SKILLS_README.txt"
+        readme.write_text(
+            "Could not create workspace/skills symlink on this platform.\n"
+            "Run: bash scripts/setup-workspace.sh\n"
+            "Or copy/symlink skills/ into workspace/skills manually.\n",
+            encoding="utf-8",
+        )
+        lines.append("  workspace/skills: symlink failed (see workspace/SKILLS_README.txt)")
+
+    return lines
+
+
+def install_setup_script(dest: Path, *, force: bool) -> str:
+    scripts = dest / "scripts"
+    scripts.mkdir(parents=True, exist_ok=True)
+    dest_script = scripts / "setup-workspace.sh"
+    if dest_script.exists() and not force:
+        return "skipped"
+    existed = dest_script.exists()
+    dest_script.write_bytes(
+        (resources.files(_DEFAULTS_PKG) / "setup-workspace.sh").read_bytes()
+    )
+    dest_script.chmod(dest_script.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    return "overwritten" if existed else "created"
+
+
+def install_env_example(dest: Path, *, force: bool) -> str:
+    env_example = dest / ".env.example"
+    if env_example.exists() and not force:
+        return "skipped"
+    existed = env_example.exists()
+    _install_file(env_example, resources.files(_DEFAULTS_PKG) / "env.example", force=True)
+    return "overwritten" if existed else "created"
+
+
+def _sanitize_project_name(raw: str) -> str:
+    name = re.sub(r"[^a-z0-9._-]+", "-", raw.strip().lower()).strip("-._")
+    return name or "agent"
+
+
+def collect_extras(
+    *,
+    provider: str | None = None,
+    extras: list[str] | None = None,
+) -> list[str]:
+    """Return unique package extras: primary provider first, then extras."""
+    ordered: list[str] = []
+    seen: set[str] = set()
+
+    def _add(extra: str | None) -> None:
+        if not extra or extra in seen:
+            return
+        seen.add(extra)
+        ordered.append(extra)
+
+    effective = provider if provider is not None else _DEFAULT_PROVIDER
+    _add(provider_extra_name(effective))
+    for raw in extras or ():
+        token = normalize_extra_token(raw)
+        if token is not None:
+            _add(token)
+    return ordered
+
+
+def monkeybot_requirement(
+    *,
+    provider: str | None = None,
+    extras: list[str] | None = None,
+) -> str:
+    """Return a PyPI ``monkeybot`` / ``monkeybot[a,b]`` requirement string."""
+    ordered = collect_extras(provider=provider, extras=extras)
+    if ordered:
+        return f"monkeybot[{','.join(ordered)}]{COMPATIBLE_CORE_RANGE}"
+    return f"monkeybot{COMPATIBLE_CORE_RANGE}"
+
+
+def monkeybot_dep_for_provider(provider: str | None) -> str:
+    """Backward-compatible wrapper: provider-only requirement."""
+    return monkeybot_requirement(provider=provider)
+
+
+def write_agent_pyproject(
+    dest: Path,
+    *,
+    provider: str | None = None,
+    extras: list[str] | None = None,
+    force: bool = False,
+) -> str:
+    """Write agent-project ``pyproject.toml`` with a PyPI ``monkeybot[…]`` dep."""
+    path = dest / "pyproject.toml"
+    if path.exists() and not force:
+        return "skipped"
+    existed = path.exists()
+    dep = monkeybot_requirement(provider=provider, extras=extras)
+    name = _sanitize_project_name(dest.name)
+    path.write_text(
+        (
+            "[project]\n"
+            f'name = "{name}"\n'
+            'version = "0.1.0"\n'
+            'requires-python = ">=3.11"\n'
+            "dependencies = [\n"
+            f'  "{dep}",\n'
+            "]\n"
+        ),
+        encoding="utf-8",
+    )
+    return "overwritten" if existed else "created"
+
+
+def run_new(
+    *,
+    dest: Path,
+    force: bool,
+    provider: str | None = None,
+    model: str | None = None,
+    extras: list[str] | None = None,
+) -> list[str]:
+    """Full scaffold: config bundle, workspace, env example, and setup script."""
+    cfg_dir = dest / "monkeybot_config"
+    report = install_config_bundle(cfg_dir, force=force)
+    report.append(
+        f"  monkeybot_config/monkeybot.yaml: "
+        f"{write_active_config(cfg_dir, provider=provider, model=model, force=force)}"
+    )
+    report.extend(ensure_memory(dest, force=force))
+    report.extend(ensure_workspace(dest, force=force))
+    report.append(f"  scripts/setup-workspace.sh: {install_setup_script(dest, force=force)}")
+    report.append(f"  .env.example: {install_env_example(dest, force=force)}")
+    report.append(
+        f"  pyproject.toml: "
+        f"{write_agent_pyproject(dest, provider=provider, extras=extras, force=force)}"
+    )
+    return report