monkeybot-cli 0.2.1__py3-none-any.whl

monkeybot_cli/commands/validate.py

@@ -0,0 +1,385 @@
+"""monkeybot validate — check monkeybot.yaml and related paths."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+import httpx
+import yaml
+from monkeybot.core.config import (
+    SUPPORTED_YAML_MODEL_PROVIDERS,
+    validate_monkeybot_yaml_doc,
+    validate_provider_env,
+)
+from monkeybot.core.config.runtime_env import ENV_MAP
+from monkeybot.core.config.settings import ConfigError, normalize_model_provider
+from monkeybot.core.config.yaml_loader import load_monkeybot_yaml_dict
+
+from monkeybot_cli.config_resolve import load_agent_dotenv, resolve_config
+from monkeybot_cli.output import CommandReport, check
+
+
+def _resolve_path(base: Path, rel: str) -> Path:
+    p = Path(rel)
+    if p.is_absolute():
+        return p
+    return (base / p).resolve()
+
+
+def _flatten_to_env(doc: dict[str, Any]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for (section, key), env_name in ENV_MAP.items():
+        sec = doc.get(section)
+        if not isinstance(sec, dict) or key not in sec:
+            continue
+        raw = sec[key]
+        if raw is None:
+            continue
+        if isinstance(raw, bool):
+            out[env_name] = "true" if raw else "false"
+        else:
+            out[env_name] = str(raw)
+    gcp = doc.get("gcp") if isinstance(doc.get("gcp"), dict) else {}
+    if isinstance(gcp, dict) and gcp.get("project_id"):
+        out["GCP_PROJECT_ID"] = str(gcp["project_id"])
+    return out
+
+
+def _collect_mcp_env_refs(obj: Any) -> set[str]:
+    refs: set[str] = set()
+    if isinstance(obj, str):
+        for m in re.finditer(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}", obj):
+            refs.add(m.group(1))
+    elif isinstance(obj, dict):
+        for v in obj.values():
+            refs.update(_collect_mcp_env_refs(v))
+    elif isinstance(obj, list):
+        for v in obj:
+            refs.update(_collect_mcp_env_refs(v))
+    return refs
+
+
+def run_validate(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="validate", ok=True, config_path=None)
+
+    if config_path is None:
+        check(
+            report,
+            id="config.file.exists",
+            category="config",
+            severity="error",
+            passed=False,
+            message="monkeybot.yaml not found",
+            remediation="Run `monkeybot new` or set MONKEYBOT_CONFIG",
+        )
+        return report.emit(as_json=args.json)
+
+    report.config_path = str(config_path.resolve())
+    base = config_path.parent.parent if config_path.parent.name == "monkeybot_config" else Path.cwd()
+
+    try:
+        raw = config_path.read_text(encoding="utf-8")
+        doc = yaml.safe_load(raw)
+        check(report, id="config.yaml.parses", category="config", severity="error", passed=True)
+    except yaml.YAMLError as exc:
+        check(
+            report,
+            id="config.yaml.parses",
+            category="config",
+            severity="error",
+            passed=False,
+            message=str(exc),
+        )
+        return report.emit(as_json=args.json)
+
+    if not isinstance(doc, dict):
+        check(
+            report,
+            id="config.root.is_mapping",
+            category="config",
+            severity="error",
+            passed=False,
+            message=f"Expected mapping at root, got {type(doc).__name__}",
+        )
+        return report.emit(as_json=args.json)
+    check(report, id="config.root.is_mapping", category="config", severity="error", passed=True)
+
+    _, merged = load_monkeybot_yaml_dict(config_path)
+    includes = doc.get("includes")
+    if includes:
+        missing = []
+        if isinstance(includes, list):
+            for item in includes:
+                if isinstance(item, str):
+                    inc = (config_path.parent / item.strip()).resolve()
+                    if not inc.is_file():
+                        missing.append(str(inc))
+        check(
+            report,
+            id="config.includes.resolve",
+            category="config",
+            severity="warning",
+            passed=not missing,
+            message=f"Missing includes: {', '.join(missing)}" if missing else "All includes resolved",
+        )
+    else:
+        check(report, id="config.includes.resolve", category="config", severity="warning", passed=True, skip=True)
+
+    model = merged.get("model") if isinstance(merged.get("model"), dict) else {}
+    provider = str(model.get("provider", "")).strip().lower() if isinstance(model, dict) else ""
+    model_name = str(model.get("name", "")).strip() if isinstance(model, dict) else ""
+    check(
+        report,
+        id="model.provider.supported",
+        category="config",
+        severity="error",
+        passed=not provider or provider in SUPPORTED_YAML_MODEL_PROVIDERS,
+        message=f"model.provider '{provider}' is not supported" if provider and provider not in SUPPORTED_YAML_MODEL_PROVIDERS else "",
+        field="model.provider",
+        value=provider,
+        expected=sorted(SUPPORTED_YAML_MODEL_PROVIDERS),
+        remediation="Set model.provider to a supported value.",
+    )
+    check(
+        report,
+        id="model.name.present",
+        category="config",
+        severity="error",
+        passed=bool(model_name),
+        message="model.name is required",
+        field="model.name",
+    )
+
+    memory_uri = ""
+    paths = merged.get("paths") if isinstance(merged.get("paths"), dict) else {}
+    if isinstance(paths, dict):
+        memory_uri = str(paths.get("memory_storage_uri", ""))
+    memory_backend = "gcs" if memory_uri.startswith("gcs://") else "local"
+    check(
+        report,
+        id="memory.backend.supported",
+        category="config",
+        severity="error",
+        passed=memory_backend in {"local", "gcs", "drive"},
+        message=f"Unsupported memory backend from uri: {memory_uri}",
+    )
+
+    flat = _flatten_to_env(merged)
+    flat.update({k: v for k, v in os.environ.items() if k.startswith(("GCP_", "GOOGLE_", "ANTHROPIC_VERTEX"))})
+    norm_provider = normalize_model_provider(provider or "gemini")
+    needs_gcp = memory_backend == "gcs" or norm_provider == "vertex_anthropic"
+    gcp_present = any(
+        os.environ.get(k, "").strip() or flat.get(k, "").strip()
+        for k in ("GCP_PROJECT_ID", "VERTEX_AI_PROJECT_ID", "ANTHROPIC_VERTEX_PROJECT_ID", "GOOGLE_CLOUD_PROJECT")
+    )
+    if needs_gcp:
+        check(
+            report,
+            id="gcp.project.required",
+            category="config",
+            severity="error",
+            passed=gcp_present,
+            message="GCP project id required for gcs memory or vertex-claude provider",
+            remediation="Set gcp.project_id in monkeybot.yaml or GCP_PROJECT_ID in .env",
+        )
+    else:
+        check(report, id="gcp.project.required", category="config", severity="error", passed=True, skip=True)
+
+    try:
+        validate_monkeybot_yaml_doc(merged, env=dict(os.environ))
+        validate_provider_env({**flat, "MODEL_PROVIDER": provider or flat.get("MODEL_PROVIDER", "gemini")})
+    except ConfigError as exc:
+        check(
+            report,
+            id="model.provider.supported",
+            category="config",
+            severity="error",
+            passed=False,
+            message=str(exc).split("\n")[0],
+        )
+
+    if isinstance(paths, dict):
+        agent_md = str(paths.get("agent_md", ""))
+        if agent_md:
+            ap = _resolve_path(base, agent_md)
+            check(
+                report,
+                id="paths.agent_md.exists",
+                category="paths",
+                severity="error",
+                passed=ap.is_file(),
+                message=f"Missing AGENT.md at {ap}",
+                field="paths.agent_md",
+            )
+        skills = str(paths.get("skills_path", ""))
+        if skills:
+            sp = _resolve_path(base, skills)
+            check(
+                report,
+                id="paths.skills_path.exists",
+                category="paths",
+                severity="warning",
+                passed=sp.is_dir(),
+                message=f"Skills path missing: {sp}",
+            )
+        mcp_cfg = str(paths.get("mcp_config", ""))
+        mcp_path: Path | None = None
+        if mcp_cfg:
+            mcp_path = _resolve_path(base, mcp_cfg)
+            check(
+                report,
+                id="paths.mcp_config.exists",
+                category="paths",
+                severity="error",
+                passed=mcp_path.is_file(),
+                message=f"Missing MCP config: {mcp_path}",
+            )
+        allow = str(paths.get("command_allowlist_config", ""))
+        if allow:
+            ap = _resolve_path(base, allow)
+            check(
+                report,
+                id="paths.command_allowlist.exists",
+                category="paths",
+                severity="warning",
+                passed=ap.is_file(),
+                message=f"Missing command allowlist: {ap}",
+            )
+            if ap.is_file():
+                try:
+                    from monkeybot.core.context.tool_output_policy import (
+                        load_tool_output_policies,
+                        validate_tool_output_budgets,
+                    )
+
+                    policies = load_tool_output_policies(ap)
+                    for warn in validate_tool_output_budgets(policies):
+                        check(
+                            report,
+                            id="tool_output.budgets.sane",
+                            category="tools",
+                            severity="warning",
+                            passed=False,
+                            message=warn,
+                        )
+                except Exception as exc:
+                    check(
+                        report,
+                        id="tool_output.parse",
+                        category="tools",
+                        severity="warning",
+                        passed=False,
+                        message=f"tool_output section: {exc}",
+                    )
+        db_url = str(paths.get("db_url", ""))
+        if db_url.startswith("sqlite:///"):
+            db_file = Path(db_url.removeprefix("sqlite:///"))
+            if not db_file.is_absolute():
+                db_file = (base / db_file).resolve()
+            writable = True
+            try:
+                db_file.parent.mkdir(parents=True, exist_ok=True)
+                if db_file.exists():
+                    conn = sqlite3.connect(db_file)
+                    conn.close()
+                else:
+                    conn = sqlite3.connect(db_file)
+                    conn.close()
+            except OSError as exc:
+                writable = False
+                msg = str(exc)
+            else:
+                msg = ""
+            check(
+                report,
+                id="paths.db_url.writable",
+                category="paths",
+                severity="error",
+                passed=writable,
+                message=msg or f"SQLite path ok: {db_file}",
+            )
+
+        if mcp_path and mcp_path.is_file():
+            try:
+                mcp_doc = json.loads(mcp_path.read_text(encoding="utf-8"))
+                check(report, id="mcp.json.parses", category="mcp", severity="error", passed=True)
+                servers = mcp_doc.get("mcpServers") if isinstance(mcp_doc, dict) else None
+                shape_ok = isinstance(servers, dict)
+                check(
+                    report,
+                    id="mcp.servers.shape_valid",
+                    category="mcp",
+                    severity="error",
+                    passed=shape_ok,
+                    message="mcp.json must have mcpServers object",
+                )
+                if shape_ok and isinstance(servers, dict):
+                    refs = _collect_mcp_env_refs(servers)
+                    missing_refs = [r for r in refs if not os.environ.get(r, "").strip()]
+                    check(
+                        report,
+                        id="mcp.env_refs.resolvable",
+                        category="mcp",
+                        severity="warning",
+                        passed=not missing_refs,
+                        message=f"Unresolved MCP env refs: {', '.join(missing_refs)}" if missing_refs else "All MCP env refs set",
+                    )
+                    if args.check_mcp:
+                        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)
+                                    reachable = True
+                                    rmsg = f"{name} reachable"
+                                except Exception as exc:
+                                    reachable = False
+                                    rmsg = f"{name}: {exc}"
+                                check(
+                                    report,
+                                    id="mcp.server.reachable",
+                                    category="mcp",
+                                    severity="warning",
+                                    passed=reachable,
+                                    message=rmsg,
+                                )
+                    else:
+                        check(
+                            report,
+                            id="mcp.server.reachable",
+                            category="mcp",
+                            severity="warning",
+                            passed=True,
+                            skip=True,
+                        )
+            except json.JSONDecodeError as exc:
+                check(
+                    report,
+                    id="mcp.json.parses",
+                    category="mcp",
+                    severity="error",
+                    passed=False,
+                    message=str(exc),
+                )
+
+    return report.emit(as_json=args.json)
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p = subparsers.add_parser("validate", help="Validate monkeybot.yaml and related files")
+    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 for path resolution")
+    p.add_argument("--check-mcp", action="store_true", help="Probe MCP HTTP servers (network)")
+    p.set_defaults(func=run_validate)

monkeybot_cli/compat.py

@@ -0,0 +1,7 @@
+"""Version ranges shared by CLI packaging and agent scaffolding."""
+
+from __future__ import annotations
+
+# Floor matches published ``monkeybot-cli`` → ``monkeybot[cli]`` bound.
+# Raise together when scaffolding or gateway APIs break compatibility.
+COMPATIBLE_CORE_RANGE = ">=2.1.0,<3"

monkeybot_cli/config_resolve.py

@@ -0,0 +1,55 @@
+"""Resolve monkeybot.yaml for CLI commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from dotenv import load_dotenv
+from monkeybot.core.config.yaml_loader import (
+    load_monkeybot_yaml_dict,
+    resolve_monkeybot_config_path,
+)
+
+
+def resolve_agent_root(*, cwd: Path | None = None, config_path: Path | None = None) -> Path:
+    """Return the agent project root (directory containing monkeybot_config/ or .env)."""
+    if cwd is not None:
+        return cwd.expanduser().resolve()
+    if config_path is not None:
+        cp = config_path.expanduser().resolve()
+        if cp.parent.name == "monkeybot_config":
+            return cp.parent.parent
+        return cp.parent
+    return Path.cwd()
+
+
+def load_agent_dotenv(*, cwd: Path | None = None, config_path: Path | None = None) -> Path | None:
+    """Load ``.env`` from the agent root (``--cwd`` or parent of ``monkeybot_config``).
+
+    ``uv run`` sets the process cwd to the CLI package, so bare ``load_dotenv()`` misses
+    agent secrets. Existing environment variables are not overridden.
+    """
+    root = resolve_agent_root(cwd=cwd, config_path=config_path)
+    env_file = root / ".env"
+    if env_file.is_file():
+        load_dotenv(env_file, override=False)
+        return env_file
+    fallback = Path.cwd() / ".env"
+    if fallback.is_file() and fallback != env_file:
+        load_dotenv(fallback, override=False)
+        return fallback
+    return None
+
+
+def resolve_config(explicit: str | None, *, cwd: Path | None = None) -> Path | None:
+    """Resolve config path from --config flag or defaults."""
+    if explicit:
+        p = Path(explicit).expanduser()
+        return p.resolve() if p.is_file() else None
+    resolved_cwd = cwd.expanduser().resolve() if cwd is not None else None
+    return resolve_monkeybot_config_path(cwd=resolved_cwd)
+
+
+def load_config_doc(config_path: str | Path | None = None) -> tuple[Path | None, dict]:
+    path, doc = load_monkeybot_yaml_dict(config_path)
+    return path, doc if isinstance(doc, dict) else {}

monkeybot_cli/exit_commands.py

@@ -0,0 +1,13 @@
+"""Shared exit-command parsing for chat and talk."""
+
+from __future__ import annotations
+
+_EXIT_COMMANDS = frozenset({"/bye", "/quit", "/exit"})
+
+
+def is_exit_command(line: str) -> bool:
+    """Return True for /bye, /quit, /exit (optional trailing punctuation)."""
+    token = line.strip().lower().split(maxsplit=1)[0] if line.strip() else ""
+    while token and token[-1] in ".,!;:":
+        token = token[:-1]
+    return token in _EXIT_COMMANDS

monkeybot_cli/extras_catalog.py

@@ -0,0 +1,95 @@
+"""Catalog of agent-selectable monkeybot extras for ``monkeybot new``."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from monkeybot_cli.providers import PROVIDER_SPECS, spec_for_provider
+
+
+@dataclass(frozen=True)
+class ExtraChoice:
+    """One selectable optional-dependency row."""
+
+    key: str  # package extra name or YAML provider id (for provider menu)
+    label: str
+
+
+# Primary provider menu — keys are YAML ``model.provider`` values.
+# ``fake`` is intentionally omitted: it remains valid via ``--provider fake`` for CI/smoke.
+PROVIDER_CHOICES: tuple[ExtraChoice, ...] = (
+    ExtraChoice("gemini", "Gemini / Vertex AI"),
+    ExtraChoice("openai", "OpenAI"),
+    ExtraChoice("anthropic", "Anthropic (Claude API)"),
+    ExtraChoice("vertex-claude", "Claude on Vertex AI"),
+    ExtraChoice("aws_bedrock", "AWS Bedrock"),
+    ExtraChoice("huggingface", "Hugging Face"),
+    ExtraChoice("ollama", "Ollama (local)"),
+    ExtraChoice("nvidia", "NVIDIA NIM"),
+)
+
+# Non-provider agent features (root ``[project.optional-dependencies]`` names).
+FEATURE_CHOICES: tuple[ExtraChoice, ...] = (
+    ExtraChoice("postgres", "Postgres conversation store (parallel subagents)"),
+    ExtraChoice("firestore", "Firestore storage"),
+    ExtraChoice("gcs", "Google Cloud Storage"),
+    ExtraChoice("sandbox", "OpenSandbox code execution"),
+    ExtraChoice("web-search", "DuckDuckGo web search (ddgs)"),
+    ExtraChoice("observability", "OpenTelemetry tracing"),
+    ExtraChoice("scheduler", "Cron scheduler"),
+    ExtraChoice("council", "Council / multi-agent GCS helpers"),
+    ExtraChoice("aws", "AWS helpers (boto3)"),
+    ExtraChoice("realtime", "Realtime WebSocket gateway support"),
+    ExtraChoice("realtime-gemini", "Gemini Live realtime"),
+    ExtraChoice("cli-realtime", "CLI talk audio (PortAudio / push-to-talk)"),
+)
+
+_FEATURE_KEYS = frozenset(c.key for c in FEATURE_CHOICES)
+_KNOWN_PACKAGE_EXTRAS = frozenset(
+    {s.extra for s in PROVIDER_SPECS.values() if s.extra} | _FEATURE_KEYS
+)
+
+
+def provider_extra_name(yaml_provider: str | None) -> str | None:
+    """Map a YAML provider id to its package extra (None for fake / unknown)."""
+    if not yaml_provider:
+        return None
+    spec = spec_for_provider(yaml_provider)
+    return spec.extra if spec is not None else None
+
+
+def normalize_extra_token(raw: str) -> str | None:
+    """Accept ``--with`` tokens: feature keys, package extras, or YAML provider aliases."""
+    token = raw.strip()
+    if not token:
+        return None
+    if token in _FEATURE_KEYS:
+        return token
+    if token in _KNOWN_PACKAGE_EXTRAS:
+        return token
+    spec = spec_for_provider(token)
+    if spec is not None:
+        return spec.extra  # may be None for fake — caller should skip
+    # hyphen/underscore variants for features
+    alt = token.replace("_", "-")
+    if alt in _FEATURE_KEYS:
+        return alt
+    alt2 = token.replace("-", "_")
+    spec = spec_for_provider(alt2)
+    if spec is not None:
+        return spec.extra
+    return None
+
+
+def additional_provider_extra_choices(primary_yaml: str | None) -> tuple[ExtraChoice, ...]:
+    """Other provider package extras (beyond the primary) for multi-select."""
+    primary_extra = provider_extra_name(primary_yaml)
+    seen: set[str] = set()
+    rows: list[ExtraChoice] = []
+    for choice in PROVIDER_CHOICES:
+        extra = provider_extra_name(choice.key)
+        if extra is None or extra == primary_extra or extra in seen:
+            continue
+        seen.add(extra)
+        rows.append(ExtraChoice(extra, choice.label))
+    return tuple(rows)

monkeybot_cli/gateway_health.py

@@ -0,0 +1,34 @@
+"""Gateway health polling helpers shared by chat and talk."""
+
+from __future__ import annotations
+
+import subprocess
+import time
+
+import httpx
+
+
+def wait_for_health(
+    base: str, proc: subprocess.Popen[str] | None, timeout_s: float = 30.0
+) -> bool:
+    """Poll ``GET {base}/health`` until 200, process dies, or timeout."""
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if proc is not None and proc.poll() is not None:
+            return False
+        try:
+            resp = httpx.get(f"{base}/health", timeout=2.0)
+            if resp.status_code == 200:
+                return True
+        except httpx.HTTPError:
+            pass
+        time.sleep(0.3)
+    return False
+
+
+def health_ok(base: str) -> bool:
+    """Single-shot health check."""
+    try:
+        return httpx.get(f"{base}/health", timeout=2.0).status_code == 200
+    except httpx.HTTPError:
+        return False

monkeybot_cli/main.py

@@ -0,0 +1,38 @@
+"""monkeybot CLI entry point."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from monkeybot_cli.commands import chat, doctor, loop, new, run_cmd, talk, validate
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="monkeybot",
+        description="Create, configure, validate, and chat with monkeybot agents.",
+    )
+    parser.add_argument("--json", action="store_true", help="JSON output (validate/doctor)")
+    sub = parser.add_subparsers(dest="command", required=True)
+    new.register(sub)
+    validate.register(sub)
+    doctor.register(sub)
+    run_cmd.register(sub)
+    chat.register(sub)
+    talk.register(sub)
+    loop.register(sub)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+    args = build_parser().parse_args(argv)
+    try:
+        return int(args.func(args))
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())