monkeybot 3.7.0__tar.gz → 3.9.0__tar.gz

monkeybot-3.9.0/.cursor/hooks/pre-pr.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Block pull-request creation until local CI has passed for this repo."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+REPO_NAME = os.path.basename(ROOT)
+CREATE_PR = re.compile(r"(?:^|[^\w./-])gh\s+pr\s+create\b")
+REPO_FLAG = re.compile(r"(?:^|\s)(?:-R|--repo)(?:=|\s+)(\S+)")
+CD = re.compile(r"(?:^|[;&|]\s*)cd\s+([^;&|\n]+)")
+
+
+def emit(permission: str, message: str | None = None) -> None:
+    payload: dict[str, str] = {"permission": permission}
+    if message:
+        payload["user_message"] = message
+        payload["agent_message"] = message
+    json.dump(payload, sys.stdout)
+    sys.stdout.write("\n")
+
+
+def allow() -> None:
+    emit("allow")
+    raise SystemExit(0)
+
+
+def deny(message: str) -> None:
+    emit("deny", message)
+    raise SystemExit(0)
+
+
+def in_repo(path: str) -> bool:
+    try:
+        return os.path.commonpath(
+            [os.path.realpath(path), os.path.realpath(ROOT)]
+        ) == os.path.realpath(ROOT)
+    except ValueError:
+        return False
+
+
+def is_this_repo(value: str) -> bool:
+    name = value.rstrip("/").split("/")[-1]
+    if name.endswith(".git"):
+        name = name[: -len(".git")]
+    return name == REPO_NAME
+
+
+def effective_cwd(cwd: str, command: str) -> str:
+    base = cwd or ROOT
+    matches = CD.findall(command)
+    if not matches:
+        return base
+    target = matches[-1].strip().strip('"').strip("'")
+    target = os.path.expanduser(target)
+    if not os.path.isabs(target):
+        target = os.path.normpath(os.path.join(base, target))
+    return target
+
+
+def run_ci() -> int:
+    completed = subprocess.run(
+        ["bash", "scripts/ci-local.sh", "--if-needed"],
+        cwd=ROOT,
+        stdout=sys.stderr,
+    )
+    return completed.returncode
+
+
+def gate_shell(data: dict) -> None:
+    command = str(data.get("command") or "")
+    if CREATE_PR.search(command) is None:
+        allow()
+
+    flagged = REPO_FLAG.search(command)
+    if flagged is not None:
+        if not is_this_repo(flagged.group(1)):
+            allow()
+    else:
+        cwd = str(data.get("cwd") or "")
+        if cwd or CD.search(command):
+            if not in_repo(effective_cwd(cwd, command)):
+                allow()
+        else:
+            roots = data.get("workspace_roots") or []
+            if len(roots) != 1 or not in_repo(str(roots[0])):
+                deny(
+                    "Set the shell working directory to the repository before creating a pull request "
+                    "so local CI runs in the right project."
+                )
+
+    if run_ci() != 0:
+        deny("Local CI failed, so the pull request was not created.")
+    allow()
+
+
+def gate_mcp(data: dict) -> None:
+    if data.get("tool_name") != "create_pull_request":
+        allow()
+    raw = data.get("tool_input") or {}
+    if isinstance(raw, str):
+        try:
+            payload = json.loads(raw) if raw else {}
+        except json.JSONDecodeError:
+            deny("create_pull_request input was not valid JSON, so local CI did not run.")
+    elif isinstance(raw, dict):
+        payload = raw
+    else:
+        payload = {}
+    repo = str(payload.get("repo") or "")
+    if not repo:
+        deny(
+            "create_pull_request is missing a repo, so local CI cannot tell which project to test."
+        )
+    if not is_this_repo(repo):
+        allow()
+    if run_ci() != 0:
+        deny("Local CI failed, so the pull request was not created.")
+    allow()
+
+
+def main() -> None:
+    try:
+        data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        deny("Local CI hook received invalid input.")
+    event = str(data.get("hook_event_name") or "")
+    if event == "beforeMCPExecution" or (
+        not event and data.get("tool_name") == "create_pull_request"
+    ):
+        gate_mcp(data)
+    else:
+        gate_shell(data)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as exc:
+        deny(f"Local CI hook failed: {exc}")

monkeybot-3.9.0/.cursor/hooks.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "hooks": {
+    "beforeShellExecution": [
+      {
+        "command": ".cursor/hooks/pre-pr.py",
+        "matcher": "gh\\s+pr\\s+create",
+        "timeout": 2400,
+        "failClosed": true
+      }
+    ],
+    "beforeMCPExecution": [
+      {
+        "command": ".cursor/hooks/pre-pr.py",
+        "matcher": "create_pull_request",
+        "timeout": 2400,
+        "failClosed": true
+      }
+    ]
+  }
+}

monkeybot-3.9.0/.cursor/skills/mb-retro/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: mb-retro
+description: >-
+  Review one MonkeyBot session transcript and propose environment fixes
+  (checks, verifier criteria, AGENT.md pointers, tool access). Use ONLY when
+  the user explicitly asks for /mb-retro, a MonkeyBot retro, or to review a
+  MonkeyBot transcript for why the agent struggled. Do not run during ordinary
+  coding, and do not edit anything until the user picks a candidate.
+disable-model-invocation: true
+---
+
+# mb-retro
+
+Look at one MonkeyBot session and propose changes to the agent's environment so the next run goes better. Propose only. Edit nothing until the user picks a candidate.
+
+This is the MonkeyBot form of a session retro. It does not review the code the session produced. If the user wants a verdict on a diff, that is a code review, not this skill.
+
+## Input
+
+A session id, a session directory, or a `transcript.ndjson` path. Transcripts live under `{workspace}/.monkeybot/transcripts/` and exist only when `runtime.transcript_enabled` is true in `monkeybot.yaml`.
+
+From the monkeybot repo:
+
+```bash
+uv run monkeybot trace list --cwd <agent-root>
+uv run monkeybot trace digest <session-id-or-path> --cwd <agent-root>
+```
+
+If the user does not name a session, run `trace list` and suggest the session with the highest `score`. Say which one you are using. Do not retro every session.
+
+## Read
+
+1. Run `uv run monkeybot trace digest <id>`. That output is already resolved. Do not hand-expand `text_seq`, `result_seq`, `schema_seq`, `content_seq`, or `base_seq` diffs.
+2. Open one record only when the digest line is not enough: `uv run monkeybot trace digest <id> --seq N`. Repeat `--seq` for a few records, not the whole file.
+3. Subagent work is inlined under the `task` call that started it, from `{session}/subagents/`. Runs the digest cannot tie to a call appear under `Unlinked subagent runs`. If a line says `no child transcript`, say so and do not invent what the child did.
+4. A `--seq` record with `text_error: diff_mismatch` was written by an older harness whose prompt diff cannot be rebuilt. Do not quote its text.
+
+A smooth digest (score 0, short timeline, no interventions) has little to teach. Say that and stop.
+
+## Find struggle moments
+
+Every candidate must cite one or more `@seq` lines from this digest. Discard any candidate you cannot point at a specific moment. Do not fill categories with generic advice.
+
+Look for:
+
+- Tool errors, especially the same `error_kind` more than once
+- `HarnessIntervention` (`doom_loop`, `truncated_batch`, `empty_completion`, `post_tool_empty`, `background_jobs_nudge`, `compaction_fallback`, `max_turns`, `verifier_replan`)
+- Steers, verifier verdicts, empty assistant replies, context summaries
+- Slow tools and repeated identical calls
+- A long search before a fact that a pointer would have named
+- A subagent that struggled while the parent looked fine
+
+## Classify
+
+Put each moment in one category. The category decides where the fix goes.
+
+| What went wrong | Propose |
+| --- | --- |
+| Slow to find a fact | A navigation pointer in the agent's `AGENT.md`, a skill description, or a memory entry |
+| A mechanical mistake | An inspector or `PRE_TOOL` hook, tighter tool-schema validation, `permissions.yaml` or a path grant, or a guard threshold |
+| A judgement-call miss | A verifier criterion. The verifier is the reviewer. |
+| Bloated `AGENT.md` or harness prompt (`src/monkeybot/core/prompts/harness_prompt.py`) | Move the steering into an on-demand skill, or delete the no-op lines |
+| An expensive tool call | Trim tool output, spill it to a file, or load tools progressively |
+| Missing information or access | An MCP server, a tool, or wider permissions |
+| The agent behaved reasonably and the harness misbehaved | A code fix plus a regression test in `tests/`, or an eval scenario in `evals/scenarios/` |
+
+## Rules
+
+- A mechanical problem gets a check that can fail, never a sentence in a steering file.
+- `AGENT.md` gets navigation pointers only. Do not add new standing rules there, and do not add them to a root `AGENTS.md` or `CLAUDE.md`.
+- If a check already exists but is not wired up, the fix is to wire it, not to write a second one.
+- A missing guardrail (no test or eval covers this failure) is its own finding.
+- Rank by severity for the next session, not by how loud the log line was. A quiet expensive miss can outrank a noisy cheap one. Say that the order is a draft.
+- Do not propose deleting lint rules, hooks, or CI jobs from other sessions. This skill sees one transcript.
+
+## Output
+
+Ranked candidates, most severe first. For each one:
+
+1. **Moment** — quote the digest lines and their `@seq` numbers.
+2. **Category** — one row from the table.
+3. **Target** — the exact file or config key.
+4. **Change** — the proposed check, pointer, criterion, or deletion, in a few lines. Not a patch yet.
+
+Then stop and ask which candidates to apply. Do not edit files, install hooks, or change `monkeybot.yaml` before that.

monkeybot-3.9.0/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+# Automatic runs are off. Pushing a branch runs this same suite locally
+# (scripts/ci-local.sh via the pre-push hook). Dispatch this workflow from the
+# Actions tab only when you want a GitHub-hosted run.
+name: CI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  python:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install ripgrep and GitHub CLI
+        run: sudo apt-get update && sudo apt-get install -y ripgrep gh
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      - name: Sync dependencies
+        run: uv sync --extra claude --extra vertex-claude --extra bedrock --extra firestore
+
+      - name: Ruff format
+        run: uv run ruff format --check .
+
+      - name: Mypy
+        run: uv run mypy src/monkeybot
+
+      - name: Pytest
+        run: uv run pytest tests/ -q
+
+      - name: CLI pytest
+        working-directory: cli
+        run: |
+          uv sync
+          uv run pytest -q
+
+      - name: Browser MCP pytest
+        working-directory: integrations/browser-mcp
+        run: |
+          uv sync --dev
+          uv run pytest -q
+
+      - name: Evals self-checks (no live agent, no model calls)
+        run: |
+          uv sync --extra evals
+          uv run python evals/test_assertions.py
+          uv run python evals/test_report.py
+          uv run python evals/test_runner_sse.py

monkeybot-3.9.0/.pre-commit-config.yaml

@@ -0,0 +1,36 @@
+# Pre-commit hooks for monkeybot
+# Install: uv run pre-commit install && uv run pre-commit install --hook-type pre-push
+# Run the commit hooks manually: uv run pre-commit run --all-files
+# Run the full pull-request suite: bash scripts/ci-local.sh
+
+repos:
+  - repo: local
+    hooks:
+      - id: ruff-format
+        name: ruff format
+        entry: uv run ruff format --check .
+        language: system
+        pass_filenames: false
+        always_run: true
+
+      - id: mypy
+        name: mypy (src/monkeybot)
+        entry: uv run mypy src/monkeybot
+        language: system
+        pass_filenames: false
+        always_run: true
+
+      - id: pytest
+        name: pytest (changed tests or collection check)
+        entry: bash scripts/precommit-pytest.sh
+        language: system
+        files: ^(src/monkeybot|tests)/.*\.py$
+        pass_filenames: true
+
+      - id: local-ci
+        name: local CI (ruff format, mypy, pytest, cli, browser MCP, eval self-checks)
+        entry: bash scripts/ci-local.sh --if-needed
+        language: system
+        pass_filenames: false
+        always_run: true
+        stages: [pre-push]

monkeybot-3.9.0/BACKLOG.md

@@ -0,0 +1,61 @@
+# monkeybot Backlog
+
+---
+
+## Up Next — Major Priorities
+
+### 1. Chat Integration
+- **Google Chat gateway** — incoming webhook + event handler for Google Chat spaces.
+- **Slack gateway** — Slack Events API / socket mode integration.
+
+### 2. Sandbox Workspace Protection
+- Add a hard-coded deny layer inside `SandboxExecutor` that blocks `run_command` from targeting harness-owned paths: `.monkeybot/`, `monkeybot.yaml`, `*.env`, `.agents/`, `config/`.
+- Path-level policy at the executor — distinct from `command_allowlist.yaml` which is command-level. Agent should retain free rw access to `./code/`, `./data/`, etc.
+
+### 3. CLI-managed optional service dependencies
+- `monkeybot chat` / `run` only spawn the gateway process; they don't start the Docker-backed optional services some `monkeybot.yaml` configs require: OpenSandbox (`sandbox.enabled`), Firestore emulator (`paths.db_url: firestore://...`), or the observability stack (Phoenix/Langfuse/OTel collector). Those used to be orchestrated by a demo `run.sh`; the CLI alone still can't fully run an agent that uses those features.
+- Decide and implement: should the CLI (`doctor`, `run`, `chat`) detect these from config and actually start/stop the containers, or just validate/warn with remediation hints while the user manages Docker manually?
+- Open sub-questions if going the "CLI starts services" route: where do per-project Docker assets live (`opensandbox.docker.toml`, OTel collector yaml, compose files) — agent-project-owned files referenced from `monkeybot.yaml`, or CLI-shipped generic templates; and is the sandbox worker image (project-specific extra deps) something the CLI should build, or stay manual/documented.
+
+---
+
+## Do Later
+
+### Connectors
+- **CLI gateway** — interactive stdin/stdout beyond the existing `monkeybot chat` / `talk` clients.
+- **Webhook gateway** — generic HTTP + HMAC ingress for third-party chat products.
+- **Expanded `python -m monkeybot` surface** — additional operator subcommands (`usage` / `schedule`, etc.) as needed.
+
+### Cloud Deployments
+- **GCP server** — GCE / GKE deployment option (docs + examples exist; no IaC).
+- **AWS serverless** — Lambda + API Gateway (example handler exists; not a full deploy path).
+- **AWS server** — EC2 / ECS deployment option.
+- **Docker CI image matrix** — multi-extras build matrix in CI.
+
+### Infra
+- **Postgres as production default** — backend exists; gateway still defaults to SQLite; decide when/if this becomes the default.
+- **Firestore usage aggregation doesn't scale** — `FirestoreUsageStore.summary()`/`breakdown()` (agent-wide, no `thread_id`) stream the entire `turn_usage` collection into memory and aggregate in Python. Fine at small scale; revisit with a Firestore aggregation query or a scheduled rollup doc if `/usage` traffic or data volume grows.
+
+### MCP
+- **MCP distro linkage** — confirm scaffolded `monkeybot.yaml` paths (`paths.mcp_config`, `paths.skills_path`) match deployment; smoke-test against real MCP servers beyond the bundled examples.
+
+### Tooling *(intentionally dropped — not completed)*
+
+Product decision to stop tracking these as active backlog items (not claiming they shipped):
+
+- **File-op tool audit** — Keep `write_file`; no plan to replace it with `create_file` + `find_and_replace` only.
+- **Custom subagents** — Named profiles with per-persona skills / MCP selections remain out of scope for now; workers continue to load the global skills path and `MCP_CONFIG`.
+
+### Future platforms *(not scheduled)*
+
+Moved from README — longer-term / speculative integrations without active implementation:
+
+- **Azure OpenAI** — Azure-hosted OpenAI models
+- **Azure Blob Storage** — memory backend (`[azure]` extra; docs note as planned)
+- **Azure Key Vault** — secrets for Azure deployments
+- **AWS Secrets Manager** — secret resolver at runtime
+- **GCP Secret Manager** — finish `secrets.provider: gcp_secret_manager` wiring (schema exists; resolver not shipped)
+- **Microsoft Teams** — Teams bot interface
+- **Telegram** — Telegram bot interface
+- **DynamoDB** — checkpointer / job storage backend
+- **Cosmos DB** — Azure-native persistence options