monkeybot-cli 0.2.1__py3-none-any.whl

monkeybot_cli/commands/doctor.py

@@ -0,0 +1,293 @@
+"""monkeybot doctor — environment readiness checks."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import socket
+import subprocess
+import tomllib
+from pathlib import Path
+
+import httpx
+
+from monkeybot_cli.config_resolve import (
+    load_agent_dotenv,
+    load_config_doc,
+    resolve_agent_root,
+    resolve_config,
+)
+from monkeybot_cli.output import CommandReport, check
+from monkeybot_cli.providers import credentials_present, extra_module, spec_for_provider
+from monkeybot_cli.runtime_python import resolve_runtime_python, run_probe
+
+
+def _port_free(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            s.bind(("127.0.0.1", port))
+            return True
+        except OSError:
+            return False
+
+
+def _runtime_python_version(runtime, agent_root: Path) -> tuple[int, int, int]:
+    """Ask the runtime interpreter for its version (major, minor, micro)."""
+    code = "import sys; print(sys.version_info[0], sys.version_info[1], sys.version_info[2])"
+    kwargs: dict[str, object] = {}
+    if runtime.source == "uv":
+        kwargs["cwd"] = str(agent_root)
+    proc = subprocess.run(
+        [*runtime.argv, "-c", code],
+        capture_output=True,
+        text=True,
+        timeout=15.0,
+        **kwargs,
+    )
+    if proc.returncode != 0:
+        return (0, 0, 0)
+    parts = proc.stdout.strip().split()
+    if len(parts) < 3:
+        return (0, 0, 0)
+    try:
+        return (int(parts[0]), int(parts[1]), int(parts[2]))
+    except ValueError:
+        return (0, 0, 0)
+
+
+def _agent_defines_project_extra(agent_root: Path, extra: str) -> bool:
+    """True when the agent ``pyproject.toml`` declares ``extra`` as a project optional."""
+    path = agent_root / "pyproject.toml"
+    if not path.is_file():
+        return False
+    try:
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError):
+        return False
+    project = data.get("project")
+    if not isinstance(project, dict):
+        return False
+    optional = project.get("optional-dependencies")
+    return isinstance(optional, dict) and extra in optional
+
+
+def _extra_remediation(extra: str, agent_root: Path, runtime) -> str:
+    """Remediation text pointing at the agent project, not the CLI env."""
+    if runtime.source == "cli":
+        return (
+            "Config-only tree: install in the CLI env — "
+            f"uv tool install --with 'monkeybot[{extra}]' monkeybot-cli"
+        )
+    if _agent_defines_project_extra(agent_root, extra):
+        return f"Install in the agent project: cd {agent_root} && uv sync --extra {extra}"
+    return (
+        f"Add monkeybot[{extra}] to {agent_root}/pyproject.toml dependencies, "
+        f"then run: cd {agent_root} && uv sync"
+    )
+
+
+def run_doctor(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)
+    report = CommandReport(command="doctor", ok=True, config_path=None)
+    if config_path:
+        report.config_path = str(config_path.resolve())
+
+    agent_root = resolve_agent_root(cwd=cwd, config_path=config_path)
+    runtime = resolve_runtime_python(agent_root)
+
+    py_version = _runtime_python_version(runtime, agent_root)
+    py_ok = py_version >= (3, 11)
+    check(
+        report,
+        id="env.python.version",
+        category="env",
+        severity="error",
+        passed=py_ok,
+        message=f"Python {py_version[0]}.{py_version[1]} ({runtime.source})",
+        value=f"{py_version[0]}.{py_version[1]}.{py_version[2]}",
+        remediation=None if py_ok else "Install Python 3.11+ in the agent project environment",
+    )
+
+    _, doc = load_config_doc(str(config_path) if config_path else None)
+    model = doc.get("model") if isinstance(doc.get("model"), dict) else {}
+    provider = str(model.get("provider", "gemini")) if isinstance(model, dict) else "gemini"
+    spec = spec_for_provider(provider)
+
+    if spec and spec.extra:
+        installed = run_probe(
+            runtime,
+            f"import importlib.util, sys; sys.exit(0 if importlib.util.find_spec({extra_module(spec.extra)!r}) else 1)",
+        )
+        check(
+            report,
+            id="provider.extra.installed",
+            category="provider",
+            severity="error",
+            passed=installed,
+            message=f"Extra '{spec.extra}' {'installed' if installed else 'missing'} in {runtime.source} env",
+            field="model.provider",
+            value=provider,
+            remediation=_extra_remediation(spec.extra, agent_root, runtime),
+        )
+    else:
+        check(
+            report,
+            id="provider.extra.installed",
+            category="provider",
+            severity="error",
+            passed=True,
+            skip=True,
+        )
+
+    if spec:
+        creds = credentials_present(spec)
+        check(
+            report,
+            id="provider.credentials.present",
+            category="provider",
+            severity="error",
+            passed=creds,
+            message="Provider credentials detected" if creds else "No provider credentials found",
+            remediation="Set API keys or ADC in .env (see .env.example)",
+        )
+        if spec.gcp_adc:
+            adc_path = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS", "")
+            adc_ok = bool(adc_path) and Path(adc_path).is_file()
+            check(
+                report,
+                id="gcp.adc.valid",
+                category="provider",
+                severity="warning",
+                passed=adc_ok or creds,
+                message="GOOGLE_APPLICATION_CREDENTIALS set and file exists"
+                if adc_ok
+                else "ADC file not set (may use gcloud auth)",
+                skip=not spec.gcp_adc,
+            )
+    else:
+        check(
+            report,
+            id="provider.credentials.present",
+            category="provider",
+            severity="error",
+            passed=False,
+            skip=True,
+        )
+
+    runtime_cfg = doc.get("runtime") if isinstance(doc.get("runtime"), dict) else {}
+    port = int(runtime_cfg.get("port", 8080)) if isinstance(runtime_cfg, dict) else 8080
+    free = _port_free(port)
+    check(
+        report,
+        id="runtime.port.free",
+        category="runtime",
+        severity="warning",
+        passed=free,
+        message=f"Port {port} {'available' if free else 'in use'}",
+        value=port,
+    )
+
+    web = doc.get("web_search") if isinstance(doc.get("web_search"), dict) else {}
+    backend = str(web.get("backend", "duckduckgo")) if isinstance(web, dict) else "duckduckgo"
+    if backend == "none":
+        check(
+            report,
+            id="web_search.backend.ready",
+            category="tools",
+            severity="warning",
+            passed=True,
+            skip=True,
+        )
+    elif backend == "duckduckgo":
+        if run_probe(runtime, "import ddgs"):
+            check(
+                report,
+                id="web_search.backend.ready",
+                category="tools",
+                severity="warning",
+                passed=True,
+                message="duckduckgo available",
+                value=backend,
+            )
+        else:
+            check(
+                report,
+                id="web_search.backend.ready",
+                category="tools",
+                severity="warning",
+                passed=False,
+                message="ddgs not installed",
+                remediation=_extra_remediation("web-search", agent_root, runtime),
+                value=backend,
+            )
+    else:
+        key_var = "TAVILY_API_KEY" if backend == "tavily" else "FIRECRAWL_API_KEY"
+        has_key = bool(os.environ.get(key_var, "").strip())
+        check(
+            report,
+            id="web_search.backend.ready",
+            category="tools",
+            severity="warning",
+            passed=has_key,
+            message=f"{key_var} {'set' if has_key else 'missing'}",
+            value=backend,
+        )
+
+    if args.check_mcp and config_path:
+        paths = doc.get("paths") if isinstance(doc.get("paths"), dict) else {}
+        mcp_rel = str(paths.get("mcp_config", "")) if isinstance(paths, dict) else ""
+        if mcp_rel:
+            base = (
+                config_path.parent.parent
+                if config_path.parent.name == "monkeybot_config"
+                else Path.cwd()
+            )
+            mcp_path = Path(mcp_rel) if Path(mcp_rel).is_absolute() else (base / mcp_rel)
+            if mcp_path.is_file():
+                mcp_doc = json.loads(mcp_path.read_text(encoding="utf-8"))
+                servers = mcp_doc.get("mcpServers", {})
+                if isinstance(servers, dict):
+                    for name, srv in servers.items():
+                        if not isinstance(srv, dict):
+                            continue
+                        url = srv.get("url")
+                        if isinstance(url, str) and url.startswith("http"):
+                            try:
+                                httpx.get(url, timeout=3.0)
+                                ok = True
+                                msg = f"{name} ok"
+                            except Exception as exc:
+                                ok = False
+                                msg = str(exc)
+                            check(
+                                report,
+                                id="mcp.server.reachable",
+                                category="mcp",
+                                severity="warning",
+                                passed=ok,
+                                message=msg,
+                            )
+    else:
+        check(
+            report,
+            id="mcp.server.reachable",
+            category="mcp",
+            severity="warning",
+            passed=True,
+            skip=True,
+        )
+
+    return report.emit(as_json=args.json)
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p = subparsers.add_parser("doctor", help="Check environment readiness for running the agent")
+    p.add_argument("--json", action="store_true", help="Emit JSON report")
+    p.add_argument("--config", help="Path to monkeybot.yaml")
+    p.add_argument("--cwd", help="Working directory")
+    p.add_argument("--check-mcp", action="store_true", help="Probe MCP HTTP servers")
+    p.set_defaults(func=run_doctor)

monkeybot_cli/commands/loop.py

@@ -0,0 +1,207 @@
+"""monkeybot loop — manage prompt-first scheduled loops."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import httpx
+
+from monkeybot_cli.config_resolve import load_agent_dotenv, load_config_doc, resolve_agent_root, resolve_config
+
+DEFAULT_GATEWAY_PORT = 8000
+
+
+def _port_from_config(config_path: Path | None) -> int:
+    if config_path is None:
+        return DEFAULT_GATEWAY_PORT
+    _, doc = load_config_doc(config_path)
+    runtime = doc.get("runtime") if isinstance(doc.get("runtime"), dict) else {}
+    try:
+        return int(runtime.get("port", DEFAULT_GATEWAY_PORT))
+    except (TypeError, ValueError):
+        return DEFAULT_GATEWAY_PORT
+
+
+def _gateway_url(args: argparse.Namespace, config_path: Path | None) -> str:
+    if args.url:
+        return args.url.rstrip("/")
+    port = args.port if args.port else _port_from_config(config_path)
+    return f"http://127.0.0.1:{port}"
+
+
+def _read_prompt(args: argparse.Namespace) -> str:
+    if args.prompt_file:
+        return Path(args.prompt_file).read_text(encoding="utf-8").strip()
+    if args.prompt:
+        return args.prompt.strip()
+    if not sys.stdin.isatty():
+        return sys.stdin.read().strip()
+    raise SystemExit("Provide --prompt, --prompt-file, or pipe the plan on stdin.")
+
+
+def _post_json(url: str, path: str, payload: dict[str, object]) -> dict[str, object]:
+    with httpx.Client(timeout=60.0) as client:
+        resp = client.post(f"{url}{path}", json=payload)
+        if resp.status_code >= 400:
+            raise SystemExit(f"{resp.status_code} {resp.text}")
+        data = resp.json()
+        if not isinstance(data, dict):
+            raise SystemExit("unexpected response shape")
+        return data
+
+
+def _get_json(url: str, path: str) -> dict[str, object]:
+    with httpx.Client(timeout=60.0) as client:
+        resp = client.get(f"{url}{path}")
+        if resp.status_code >= 400:
+            raise SystemExit(f"{resp.status_code} {resp.text}")
+        data = resp.json()
+        if not isinstance(data, dict):
+            raise SystemExit("unexpected response shape")
+        return data
+
+
+def _confirm_loop_start(args: argparse.Namespace, prompt: str) -> None:
+    if args.yes:
+        return
+    guards: list[str] = []
+    if args.max_ticks is not None:
+        guards.append(f"max_ticks={args.max_ticks}")
+    if args.max_runtime:
+        guards.append(f"max_runtime={args.max_runtime}")
+    if args.unbounded:
+        guard_text = "UNBOUNDED (no max_ticks/max_runtime)"
+    elif guards:
+        guard_text = ", ".join(guards)
+    else:
+        guard_text = "(guards validated above)"
+    preview = prompt if len(prompt) <= 400 else prompt[:400] + "…"
+    print(
+        "Start scheduled loop?\n"
+        f"- session: {args.session_id}\n"
+        f"- interval: {args.interval}\n"
+        f"- loop_id: {args.loop_id or '(auto)'}\n"
+        f"- guards: {guard_text}\n\n"
+        f"Plan:\n{preview or '(empty prompt)'}"
+    )
+    if sys.stdin.isatty():
+        answer = input("Proceed? [y/N] ").strip().lower()
+        if answer not in {"y", "yes"}:
+            raise SystemExit("Aborted.")
+        return
+    raise SystemExit("Refusing to start loop without --yes on non-interactive stdin.")
+
+
+def run_loop_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)
+    url = _gateway_url(args, config_path)
+    prompt = _read_prompt(args)
+    payload: dict[str, object] = {
+        "prompt": prompt,
+        "interval": args.interval,
+        "session_id": args.session_id,
+        "skip_if_busy": not args.queue_if_busy,
+    }
+    if args.loop_id:
+        payload["loop_id"] = args.loop_id
+    if args.max_ticks is not None:
+        payload["max_ticks"] = args.max_ticks
+    if args.max_runtime:
+        payload["max_runtime"] = args.max_runtime
+    if args.unbounded:
+        payload["unbounded"] = True
+    if not args.unbounded and args.max_ticks is None and not args.max_runtime:
+        raise SystemExit(
+            "Provide --max-ticks, --max-runtime, or --unbounded to set loop stop guards"
+        )
+    _confirm_loop_start(args, prompt)
+    payload["confirmed"] = True
+    data = _post_json(url, "/scheduler/loops", payload)
+    if args.json:
+        print(json.dumps(data, indent=2))
+    else:
+        loop = data.get("loop", {})
+        print(f"loop started: {loop.get('loop_id')} (session={loop.get('session_id')})")
+    return 0
+
+
+def run_loop_status(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)
+    url = _gateway_url(args, config_path)
+    if args.loop_id:
+        data = _get_json(url, f"/scheduler/loops/{args.loop_id}")
+    else:
+        data = _get_json(url, "/scheduler/loops")
+    print(json.dumps(data, indent=2) if args.json else json.dumps(data, indent=2))
+    return 0
+
+
+def _loop_action(action: str, 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)
+    if not args.loop_id:
+        raise SystemExit(f"loop {action} requires --id")
+    url = _gateway_url(args, config_path)
+    data = _post_json(url, f"/scheduler/loops/{args.loop_id}/{action}", {})
+    print(json.dumps(data, indent=2) if args.json else json.dumps(data, indent=2))
+    return 0
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    loop = subparsers.add_parser("loop", help="Manage prompt-first scheduled agent loops")
+    loop.add_argument("--cwd", help="Agent project root")
+    loop.add_argument("--config", help="Path to monkeybot.yaml")
+    loop.add_argument("--url", help="Gateway base URL")
+    loop.add_argument("--port", type=int, help="Gateway port when --url omitted")
+    loop.add_argument("--json", action="store_true", help="JSON output")
+
+    sub = loop.add_subparsers(dest="loop_command", required=True)
+
+    run = sub.add_parser("run", help="Register a scheduled loop from a prompt")
+    run.add_argument("--interval", required=True, help="Tick interval, e.g. 20s, 5m, 1h")
+    run.add_argument("--prompt", help="Loop plan / tick instructions")
+    run.add_argument("--prompt-file", help="Read loop plan from a file")
+    run.add_argument("--session-id", default="loop-main")
+    run.add_argument("--loop-id", help="Optional stable loop id")
+    run.add_argument("--max-ticks", type=int)
+    run.add_argument("--max-runtime", help="Hard wall-clock limit, e.g. 2h")
+    run.add_argument(
+        "--unbounded",
+        action="store_true",
+        help="Run without max_ticks/max_runtime guards (explicit opt-in)",
+    )
+    run.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip interactive confirmation prompt",
+    )
+    run.add_argument(
+        "--queue-if-busy",
+        action="store_true",
+        help="Do not skip ticks when the target session is busy",
+    )
+    run.set_defaults(func=run_loop_run)
+
+    status = sub.add_parser("status", help="Show one loop or list all loops")
+    status.add_argument("--id", dest="loop_id")
+    status.set_defaults(func=run_loop_status)
+
+    pause = sub.add_parser("pause", help="Pause a loop")
+    pause.add_argument("--id", dest="loop_id", required=True)
+    pause.set_defaults(func=lambda a: _loop_action("pause", a))
+
+    resume = sub.add_parser("resume", help="Resume a paused loop")
+    resume.add_argument("--id", dest="loop_id", required=True)
+    resume.set_defaults(func=lambda a: _loop_action("resume", a))
+
+    stop = sub.add_parser("stop", help="Stop a loop")
+    stop.add_argument("--id", dest="loop_id", required=True)
+    stop.set_defaults(func=lambda a: _loop_action("stop", a))