ruvnet/Bot-Generator-Bot

Última actividad de origen registrada: 11 de septiembre de 2026 a las 02:08

Catálogo de SkillsMP actualizado: 5 de noviembre de 2026 a las 19:57

skills recopiladas: 43

Estrellas en GitHub: 587
Forks en GitHub: 128

Instalar con un asistente de IA

Copia este prompt en el asistente de IA que estés usando.

Follow https://skillsmp.com/skill-install/prompt.md to install Agent Skills from https://github.com/ruvnet/Bot-Generator-Bot.

README del repositorio

Archivo de origen del README: README.md

Leer el README original

Mostrar README completo

![Bot Generator Bot](docs/assets/header.svg) # Bot Generator Bot v2 Turn a bot idea into a runnable MetaHarness agent. Choose a template, define typed outputs, then export a standalone agent or run it through the CLI or MCP. The runtime uses the actual MetaHarness kernel, native RuVector memory and optional RuFlo routing. Model calls require explicit operator configuration; compilation stays offline. The original 2023 project was a prompt collection. This preview adds working software while preserving that collection under `prompts/` for historical reference. Those older prompts are not reviewed execution policies or qualified medical/legal systems. | Capability | What it does | | --- | --- | | Complete prompt catalog | All 39 original prompts migrated, plus support, research and code starters | | Deterministic compiler | Same normalized specification produces identical manifest and SHA256 | | Typed output validation | Rejects missing/extra fields, invalid types and unsafe numbers | | Operator tool policy | Requests must be in a fixed catalog and the operator allowlist; requests never grant authority | | CLI and MCP | 50 tools, 42 prompt templates and three resources | | Runnable agents | Bounded model and tool loop, typed final output, standalone project export | | RuVector memory | Private manifest-scoped lexical retrieval with native vector search | | RuFlo routing | Optional pinned upstream keyword routing hook | | MetaHarness | Actual kernel, host adapters, agent profiles, session replay and authenticated field memory adapter | | Autogenous | Pinned upstream fitness gates with no automatic promotion | | CI delivery | Tests, dependency audit, provenance checks and downloadable artifacts | ## Quick start The qualified agent runtime requires Linux x64 and Node 24. Optional dependency trees are omitted by the repository install configuration. Clone this repository and run: ```sh npm ci --ignore-scripts node src/cli.mjs templates node src/cli.mjs compile < fixtures/support-request.json > bot-manifest.json node src/cli.mjs validate < fixtures/output-request.json npm test npm run benchmark ``` See [Claude, Codex and ChatGPT setup](docs/HOSTS.md) for installable skills and MCP configuration, and [prompt design](docs/PROMPTING.md) for the evaluated contract. The compiler input is `{ "spec": { "name", "purpose", "context", "examples", "output", "tools" } }`; use the complete JSON example in [fixtures/support-request.json](fixtures/support-request.json). Output fields support `string`, `number`, `integer` and `boolean`. All fields are required and extra fields reject. The input cap is 32 KiB, strings 8 KiB, nesting 12 levels, and output schemas 16 fields. Set `BOT_ALLOWED_TOOLS=search` locally to permit a specification to request the catalog's search tool. The agent runtime separately enforces the operator grant. Its supported tool is local memory `search`; other catalog tools are reserved and fail closed in this runtime. No tokens or provider credentials belong in specifications. `verify` checks manifest consistency, not authorship: an attacker can create a different consistent manifest. ## Install the agent skill The skill guides Claude Code and Codex through designing, validating and packaging an agent. Install it into the project where you want to use it: ```sh npx -y skills@1.5.25 add ruvnet/Bot-Generator-Bot --skill bot-generator --agent claude-code codex --copy --yes npx -y skills@1.5.25 list --json ``` For reproducible installation from a reviewed checkout, discover and install its local copy instead: ```sh npx -y skills@1.5.25 add ./skills --list npx -y skills@1.5.25 add ./skills --skill bot-generator --agent claude-code codex --copy --yes ``` The commands use project scope. Claude Code receives `.claude/skills/bot-generator`; Codex receives `.agents/skills/bot-generator`. Invoke `/bot-generator` in Claude Code or `$bot-generator` in Codex. Pinning the installer does not pin the GitHub repository revision; retain the reviewed checkout commit when reproducibility matters. Try this request: > Use bot-generator to create a support agent from supplied product instructions. Discover the support template, add a missing evidence demonstration, compile and verify it, validate an output, and export a runnable agent. Show the manifest digest and checks. Do not call a paid model. Installing a skill provides guidance. Install the repository dependencies and register its MCP server separately to make its tools callable. See the [host guide](docs/HOSTS.md) for installation qualification and scope details. ## Skills and tools for every original prompt All **39 original prompts** now have a curated typed agent template, an installable skill and a dedicated MCP builder. The [complete catalog](docs/CATALOG.md) maps every original source to its skill and tool. Original text remains unchanged for provenance; modernized contracts define the supported behavior. Discover the skills and install a selected one: ```sh npx -y skills@1.5.25 add ruvnet/Bot-Generator-Bot --list npx -y skills@1.5.25 add ruvnet/Bot-Generator-Bot --skill bgb-business-plan-bot --agent claude-code codex --copy --yes ``` Each `build_<template_id>` tool takes `{}` and returns a validated agent manifest without calling a model. For example, call `build_business_plan_bot` over MCP or run: ```sh node src/cli.mjs build_business_plan_bot > business-agent.json ``` Use `template` with the catalog ID to customize its specification before compiling. Use `agent_plan` to package the returned manifest, or `agent_run` for a bounded model task with operator configuration. Each domain skill includes its own workflow, output schema, demonstration and original source digest. The catalog resource is `ruv://bot-generator-bot/catalog`. The migrated skills create drafts, educational assistance and simulations within their stated scope. They do not claim to deploy APIs, book meetings, send messages, provide licensed professional services or run generated code. Those effects require separately available and authorized host integrations. ## Connect the MCP server After completing the quick start, register the reviewed checkout using an absolute path. The server uses local stdio and waits for protocol messages; it is not a web server or a published npm launcher. ### Claude Code ```sh claude mcp add --transport stdio --scope project bot-generator -- node /absolute/path/Bot-Generator-Bot/src/cli.mjs mcp claude mcp get bot-generator ``` ### Codex ```sh codex mcp add bot-generator -- node /absolute/path/Bot-Generator-Bot/src/cli.mjs mcp codex mcp list ``` Alternatively, use the host's supported configuration scope and trust settings with: ```toml [mcp_servers.bot-generator] command = "node" args = ["/absolute/path/Bot-Generator-Bot/src/cli.mjs", "mcp"] ``` These registration commands follow the official host documentation; automated qualification exercised the MCP protocol through the SDK, not the Claude or Codex interface. See [Claude MCP setup](https://code.claude.com/docs/en/mcp) and [Codex MCP setup](https://developers.openai.com/codex/mcp/). ### Tools, prompts and resources The 39 dedicated catalog builders complement the 11 shared tools below. See the [catalog](docs/CATALOG.md) for every builder name. All tool arguments are JSON objects with exactly the documented fields. Send `{}` to tools with no arguments. | MCP tool | Arguments | Result | | --- | --- | --- | | `status` | `{}` | Runtime policy and limits | | `templates` | `{}` | Available starter names | | `template` | `{"name":"support"}` | Editable specification; also accepts `research` or `code` | | `compile` | `{"spec": ...}` | Deterministic versioned manifest | | `verify` | `{"manifest": ...}` | Manifest consistency check | | `validate` | `{"schema": ..., "value": ...}` | Strict typed output validation | | `agent_plan` | `{"manifest": ...}` | Standalone project file map and hashes | | `agent_run` | `{"manifest": ..., "input":"task"}` | Bounded model run requiring operator configuration | | `agent_replay` | `{"manifest": ..., "id":"session UUID"}` | Local session integrity replay | | `test` | `{}` | Bounded repository validation; operator opt-in required | | `benchmark` | `{}` | Local deterministic compiler timing | Read `ruv://bot-generator-bot/policy` for execution boundaries and `ruv://bot-generator-bot/prompt-guide` for schemas, workflow and version guidance. MCP prompt discovery exposes all 39 catalog IDs plus `support`, `research` and `code`; each returns a `{spec, manifest}` starter artifact to inspect and compile. A first connection check is `templates` → `template` → `compile` → `verify`. This flow needs no provider credentials. The [host guide](docs/HOSTS.md) includes an example request and troubleshooting context. ### Operator configuration Set these in the server process environment, never in tool arguments or committed configuration: | Variable | Purpose | | --- | --- | | `BOT_ALLOW_VALIDATION=1` | Allow the MCP `test` operation | | `BOT_AGENT_STORAGE` | Absolute private directory for agent state | | `BOT_AGENT_ALLOW_LIVE=1` | Explicitly enable paid provider execution | | `BOT_AGENT_API_KEY` | Dedicated provider credential supplied through a secret manager | | `BOT_AGENT_MODEL` | Operator selected model | | `BOT_ALLOWED_TOOLS=search` | Permit local memory search when the manifest also requests it | | `BOT_AGENT_RUFLO=1` | Enable optional RuFlo keyword routing | Test subprocesses use one slot, a stripped environment, a 30 second deadline and a 64 KiB output bound. CLI `test` is an explicit local opt-in. MCP callers cannot choose executable commands, storage paths, destinations or endpoints. Installing the skill or connecting MCP does not enable paid execution. ### ChatGPT ChatGPT custom apps require a reachable remote MCP service with supported HTTP transport and authentication. This repository currently supplies local stdio MCP; it does not deploy a ChatGPT endpoint. A remote integration needs an authenticated gateway with user isolation and request limits. Installing through `npx skills` does not register a ChatGPT app. The separate federation endpoint `https://x.ruv.io/mcp` is not Bot Generator Bot's server. See [ChatGPT integration requirements](docs/HOSTS.md#chatgpt-remote-integration-boundary). ## Prompt contracts and examples New manifests use version 3. Existing version 2 manifests remain verifiable and runnable. Recompiling creates a new digest and private memory scope; it does not move old memory automatically. Examples can be task hint strings or validated demonstrations: ```json {"input":"No installation guide was supplied.","output":{"answer":"Please supply the installation guide.","needsReview":true}} ``` Demonstration outputs must match the specification's output schema. Runtime adapters receive a shared response contract and examples wrapped consistently as `{"output": ...}`. The host validates every result and rejects incomplete provider responses. MCP prompt discovery returns an inspectable `{spec, manifest}` starter artifact, not privileged system instructions. The three starter prompts now contain one validated demonstration each. Their serialized size grows from roughly 540 bytes to 1.2 to 1.4 KiB. This trades a small context increase for explicit examples and consistent contracts; model accuracy gains still need paired evaluation. See [measured prompt sizes](docs/prompt-comparison.json). ## Run or export an agent Compile a manifest using the quick start, then configure the model runtime locally: ```sh export BOT_AGENT_STORAGE=/absolute/private/agent-state export BOT_AGENT_ALLOW_LIVE=1 export BOT_AGENT_MODEL=your-approved-model # Supply BOT_AGENT_API_KEY through your local secret manager. node -e 'const fs=require("node:fs"); console.log(JSON.stringify({manifest:JSON.parse(fs.readFileSync("bot-manifest.json","utf8")),input:"Help draft a support reply"}))' | node src/cli.mjs agent-run ``` The provider endpoint is fixed to OpenAI. No live provider call is included in the test results. `BOT_AGENT_RUFLO=1` enables the actual RuFlo keyword router; this is routing advice, not a distributed swarm deployment. For memory search, the manifest must request `search` and the operator must set `BOT_ALLOWED_TOOLS=search`. `agent-plan` accepts `{ "manifest": ... }` and returns a file map for a standalone project, with a CLI, stdio MCP, harness profile and pinned direct dependencies. Inspect and materialize those files in an operator-selected directory before installation. `agent-replay` accepts `{ "manifest": ..., "id": "session UUID" }` and verifies the local session replay. Receipts are unsigned consistency evidence, not independent attestations. Runs are limited to four turns, four tool calls, 30 seconds and 512 requested completion tokens per turn. Output and input are bounded to 8 KiB. One writer can use an agent scope at a time. Local memory is capped at 64 entries and logs at 128 sessions; archive sessions deliberately. Inspect a stale writer lock after a crash before removing it. Model output and retrieved content never authorize commands, filesystem access or federation publication. See [runtime architecture and optimization](docs/adr/0002-runnable-agents.md) for the implementation and qualification boundary. ## Harness and development See the [generated agent guide](.harness/generated/README.md) and [governance gate](.harness/autogenous/README.md). Install domain dependencies above before invoking domain commands through the generated CLI. Run generated tests, build and doctor using the guide. Sessions support replay/fork; field memory requires deployment-owned storage, verifier and identity key. No live memory service or autonomous deployment is provisioned. [Architecture decision](docs/adr/0001-typed-prompt-manifests.md), [security review](docs/SECURITY.md), [validation evidence](docs/VALIDATION.md), [selection provenance](docs/selection.json), and [historical README](docs/historical-2023.md) explain the supported boundary and limitations. ## RuV ecosystem [RuFlo](https://github.com/ruvnet/ruflo) supplies optional routing. [RuVector](https://github.com/ruvnet/ruvector) supplies native memory search. [MetaHarness](https://github.com/ruvnet/metaharness) supplies this repository's tested agent harness. [Autogenous](https://github.com/ruvnet/autogenous) supplies the fitness gate. [PromptLang](https://github.com/ruvnet/promptlang) is a related typed compiler, [Dynamo MCP](https://github.com/ruvnet/dynamo-mcp) generates project scaffolds, and [Federated MCP](https://github.com/ruvnet/federated-mcp) observes [x.ruv.io](https://x.ruv.io). Related links are not claims of deployed integration.

Cargando el README del repositorio…

Skills en este repositorio

Desarrolladores de software Especialistas en gestión de proyectos Artistas de efectos especiales y animadores Otras ocupaciones informáticas

14 categorías ocupacionales · 100% clasificado

skill

ocupación

descripción

actualizado

bgb-autogpt-role-creator

Otras ocupaciones informáticas

Draft a bounded legacy-style YAML role configuration with explicit permissions and compatibility limits. Use for this Bot Generator Bot template; creates drafts or simulations within its declared scope.