monkeybot-cli 0.2.1__py3-none-any.whl

monkeybot_cli/commands/new.py

@@ -0,0 +1,207 @@
+"""monkeybot new — scaffold a bot workspace."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from monkeybot_cli.extras_catalog import (
+    FEATURE_CHOICES,
+    PROVIDER_CHOICES,
+    ExtraChoice,
+    additional_provider_extra_choices,
+    normalize_extra_token,
+)
+from monkeybot_cli.scaffold import run_new
+
+_DEFAULT_PROVIDER = "gemini"
+_DEFAULT_MODEL = "gemini-3-flash"
+
+
+def _prompt_line(prompt: str) -> str:
+    try:
+        return input(prompt)
+    except EOFError:
+        return ""
+
+
+def _prompt_single(choices: tuple[ExtraChoice, ...], *, title: str, default_key: str) -> str:
+    """Numbered single-select; Enter keeps default_key."""
+    print(title)
+    default_idx = 1
+    for i, choice in enumerate(choices, start=1):
+        marker = " (default)" if choice.key == default_key else ""
+        if choice.key == default_key:
+            default_idx = i
+        print(f"  {i}) {choice.key} — {choice.label}{marker}")
+    raw = _prompt_line(f"Choose provider [{default_idx}]: ").strip()
+    if not raw:
+        return default_key
+    if raw.isdigit():
+        idx = int(raw)
+        if 1 <= idx <= len(choices):
+            return choices[idx - 1].key
+        print(f"  invalid number; using {default_key}", file=sys.stderr)
+        return default_key
+    # Allow typing the key / alias directly
+    for choice in choices:
+        if raw.lower() == choice.key.lower():
+            return choice.key
+    print(f"  unknown provider {raw!r}; using {default_key}", file=sys.stderr)
+    return default_key
+
+
+def _prompt_multi(choices: tuple[ExtraChoice, ...], *, title: str) -> list[str]:
+    """Numbered multi-select (comma-separated). Enter = none."""
+    if not choices:
+        return []
+    print(title)
+    print("  (comma-separated numbers or names; Enter for none)")
+    for i, choice in enumerate(choices, start=1):
+        print(f"  {i}) {choice.key} — {choice.label}")
+    raw = _prompt_line("Select: ").strip()
+    if not raw:
+        return []
+    selected: list[str] = []
+    seen: set[str] = set()
+    for part in raw.split(","):
+        token = part.strip()
+        if not token:
+            continue
+        key: str | None = None
+        if token.isdigit():
+            idx = int(token)
+            if 1 <= idx <= len(choices):
+                key = choices[idx - 1].key
+            else:
+                print(f"  skipping invalid number {token}", file=sys.stderr)
+                continue
+        else:
+            for choice in choices:
+                if token.lower() == choice.key.lower():
+                    key = choice.key
+                    break
+            if key is None:
+                normalized = normalize_extra_token(token)
+                if normalized is not None:
+                    key = normalized
+                else:
+                    print(f"  skipping unknown option {token!r}", file=sys.stderr)
+                    continue
+        if key not in seen:
+            seen.add(key)
+            selected.append(key)
+    return selected
+
+
+def _resolve_extras_from_args(with_args: list[str] | None) -> tuple[list[str], list[str]]:
+    """Return (extras, unknown_tokens)."""
+    extras: list[str] = []
+    unknown: list[str] = []
+    seen: set[str] = set()
+    for raw in with_args or ():
+        for part in raw.split(","):
+            token = part.strip()
+            if not token:
+                continue
+            normalized = normalize_extra_token(token)
+            if normalized is None:
+                # fake maps to None — treat as skip only if token is fake
+                if token.lower() in {"fake"}:
+                    continue
+                unknown.append(token)
+                continue
+            if normalized not in seen:
+                seen.add(normalized)
+                extras.append(normalized)
+    return extras, unknown
+
+
+def run_new_command(args: argparse.Namespace) -> int:
+    dest = Path(args.dest).expanduser().resolve()
+    if not dest.exists():
+        dest.mkdir(parents=True, exist_ok=True)
+    if not dest.is_dir():
+        print(f"error: --dest is not a directory: {dest}", file=sys.stderr)
+        return 2
+
+    provider = args.provider
+    model = args.model
+    extras, unknown = _resolve_extras_from_args(getattr(args, "with_extras", None))
+    if unknown:
+        print(
+            f"error: unknown --with value(s): {', '.join(unknown)}",
+            file=sys.stderr,
+        )
+        return 2
+
+    if not args.yes:
+        if provider is None:
+            provider = _prompt_single(
+                PROVIDER_CHOICES,
+                title="Model provider:",
+                default_key=_DEFAULT_PROVIDER,
+            )
+        if model is None:
+            model = (
+                _prompt_line(f"Model name [{_DEFAULT_MODEL}]: ").strip() or _DEFAULT_MODEL
+            )
+        # Only prompt for optional deps when --with was not already given.
+        if not extras:
+            more_providers = additional_provider_extra_choices(provider)
+            extras.extend(
+                _prompt_multi(
+                    more_providers,
+                    title="Additional providers to install (optional):",
+                )
+            )
+            extras.extend(
+                _prompt_multi(
+                    FEATURE_CHOICES,
+                    title="Optional features to install:",
+                )
+            )
+
+    report = run_new(
+        dest=dest,
+        force=args.force,
+        provider=provider,
+        model=model,
+        extras=extras or None,
+    )
+    print(f"monkeybot scaffold under {dest}:")
+    print("\n".join(report))
+    print()
+    print("Next:")
+    print(f"  cd {dest}")
+    print("  uv sync")
+    print("  cp .env.example .env   # then add provider keys")
+    print("  monkeybot doctor")
+    print("  monkeybot chat")
+    return 0
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p = subparsers.add_parser(
+        "new",
+        help="Scaffold monkeybot_config/, workspace dirs, and agent pyproject.toml",
+    )
+    p.add_argument("--dest", type=Path, default=Path.cwd(), help="Root directory for the bot")
+    p.add_argument("--provider", help="model.provider value for monkeybot.yaml")
+    p.add_argument("--model", help="model.name value for monkeybot.yaml")
+    p.add_argument(
+        "--with",
+        dest="with_extras",
+        action="append",
+        default=[],
+        metavar="EXTRA",
+        help=(
+            "Optional dependency to include in agent pyproject.toml "
+            "(repeatable or comma-separated). Examples: postgres, sandbox, "
+            "observability, openai, bedrock, claude"
+        ),
+    )
+    p.add_argument("--force", action="store_true", help="Overwrite existing scaffold files")
+    p.add_argument("--yes", "-y", action="store_true", help="Skip interactive prompts")
+    p.set_defaults(func=run_new_command)

monkeybot_cli/commands/run_cmd.py

@@ -0,0 +1,41 @@
+"""monkeybot run — launch the SSE gateway as a subprocess."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+from pathlib import Path
+
+from monkeybot_cli.config_resolve import load_agent_dotenv, resolve_agent_root, resolve_config
+from monkeybot_cli.runtime_python import gateway_argv, resolve_runtime_python
+
+
+def run_run(args: argparse.Namespace) -> int:
+    cwd = Path(args.cwd).expanduser().resolve() if args.cwd else None
+    config_path = resolve_config(args.config, cwd=cwd)
+    load_agent_dotenv(cwd=cwd, config_path=config_path)
+    env = os.environ.copy()
+    if config_path is not None:
+        env["MONKEYBOT_CONFIG"] = str(config_path)
+    if args.port:
+        env["PORT"] = str(args.port)
+    # Derive the agent root from --cwd when given, else from --config so an
+    # off-tree config selects the right project venv / `uv run` cwd — matching
+    # `monkeybot doctor`. Falls back to cwd when neither is provided.
+    agent_root = resolve_agent_root(cwd=cwd, config_path=config_path)
+    runtime = resolve_runtime_python(agent_root)
+    cmd = gateway_argv(runtime)
+    try:
+        proc = subprocess.run(cmd, env=env, cwd=agent_root)
+        return proc.returncode
+    except KeyboardInterrupt:
+        return 130
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p = subparsers.add_parser("run", help="Start the monkeybot SSE gateway")
+    p.add_argument("--config", help="Path to monkeybot.yaml (sets MONKEYBOT_CONFIG)")
+    p.add_argument("--port", type=int, help="Listen port (sets PORT)")
+    p.add_argument("--cwd", help="Working directory for the gateway process")
+    p.set_defaults(func=run_run)

monkeybot_cli/commands/talk.py

@@ -0,0 +1,102 @@
+"""monkeybot talk — realtime WebSocket client (text and/or audio)."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+from typing import Any
+
+from monkeybot_cli.config_resolve import load_config_doc, resolve_config
+from monkeybot_cli.realtime.session import run_talk_session
+from monkeybot_cli.runtime_python import DEFAULT_PORT
+
+
+def _gateway_url_from_args(args: argparse.Namespace) -> str:
+    if getattr(args, "gateway_url", None):
+        return str(args.gateway_url).rstrip("/")
+    env = os.getenv("MONKEYBOT_GATEWAY_URL")
+    if env:
+        return env.rstrip("/")
+    cwd = Path(args.cwd).expanduser().resolve() if getattr(args, "cwd", None) else None
+    config_path = resolve_config(getattr(args, "config", None), cwd=cwd)
+    port = DEFAULT_PORT
+    if config_path is not None:
+        _, doc = load_config_doc(str(config_path))
+        runtime = doc.get("runtime") if isinstance(doc.get("runtime"), dict) else {}
+        try:
+            port = int(runtime.get("port", DEFAULT_PORT))
+        except (TypeError, ValueError):
+            port = DEFAULT_PORT
+    return f"ws://127.0.0.1:{port}"
+
+
+def run_talk(args: argparse.Namespace) -> int:
+    """Connect to the realtime gateway (audio by default, or --text)."""
+    return run_talk_session(
+        gateway_url=_gateway_url_from_args(args),
+        session_id=args.session_id,
+        text=bool(args.text),
+        ptt_key=args.ptt_key,
+        start_gateway=not args.no_start_gateway,
+        input_format=args.input_format,
+        chunk_ms=args.chunk_ms,
+        verbose=bool(args.verbose),
+    )
+
+
+def register(subparsers: Any) -> None:
+    p = subparsers.add_parser(
+        "talk",
+        help="Talk with a realtime agent (WebSocket; audio by default)",
+    )
+    p.add_argument("--cwd", help="Agent root (defaults to the current directory)")
+    p.add_argument(
+        "--config", help="Path to monkeybot.yaml (defaults to ./monkeybot_config/monkeybot.yaml)"
+    )
+    p.add_argument(
+        "--gateway-url",
+        default=None,
+        help=(
+            "Realtime gateway base URL "
+            f"(env: MONKEYBOT_GATEWAY_URL; default ws://127.0.0.1:{{runtime.port|{DEFAULT_PORT}}})"
+        ),
+    )
+    p.add_argument(
+        "--session-id",
+        default=os.getenv("MONKEYBOT_SESSION_ID"),
+        help="Session ID (generated if omitted; env: MONKEYBOT_SESSION_ID)",
+    )
+    p.add_argument(
+        "--text",
+        action="store_true",
+        help="Text-only input (no microphone); uses the chat TUI when on a TTY",
+    )
+    p.add_argument(
+        "--ptt-key",
+        default="cmd",
+        choices=("cmd", "alt", "ctrl", "space"),
+        help="Push-to-talk key to hold while speaking (default: cmd)",
+    )
+    p.add_argument(
+        "--no-start-gateway",
+        action="store_true",
+        help="Do not auto-start a local realtime gateway",
+    )
+    p.add_argument(
+        "--input-format",
+        default="pcm_s16le_24khz_mono",
+        help="Audio format, e.g. pcm_s16le_24khz_mono",
+    )
+    p.add_argument(
+        "--chunk-ms",
+        type=int,
+        default=200,
+        help="Audio chunk size in milliseconds",
+    )
+    p.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable debug logging for audio chunks and gateway events",
+    )
+    p.set_defaults(func=run_talk)