External/BMAD-METHOD
1
0
Fork 0
mirror of https://github.com/bmadcode/BMAD-METHOD.git synced 2025-12-29 16:14:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

advanced elicitation moved to workflows folder. core module extensive documentation added.

Browse Source
This commit is contained in:
Brian Madison
2025-12-28 19:44:55 +08:00
parent ea421adbf9
commit 8d679b177b
154 changed files with 680 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
docs/modules/bmb-bmad-builder/custom-content-installation.md Normal file
View File

@@ -0,0 +1,149 @@
# Custom Content Installation
This guide explains how to create and install custom BMAD content including agents, workflows, and modules. Custom content extends BMAD's functionality with specialized tools and workflows that can be shared across projects or teams.
For detailed information about the different types of custom content available, see [Custom Content](modules/bmb-bmad-builder/custom-content.md).
You can find example custom modules in the `samples/sample-custom-modules/` folder of the repository. Download either of the sample folders to try them out.
## Content Types Overview
BMAD Core supports several categories of custom content:
- Custom Stand Alone Modules
- Custom Add On Modules
- Custom Global Modules
- Custom Agents
- Custom Workflows
## Making Custom Content Installable
### Custom Modules
To create an installable custom module:
1. **Folder Structure**
- Create a folder with a short, abbreviated name (e.g., `cis` for Creative Intelligence Suite)
- The folder name serves as the module code
2. **Required File**
- Include a `module.yaml` file in the root folder (this drives questions for the final generated config.yaml at install target)
3. **Folder Organization**
Follow these conventions for optimal compatibility:
```
module-code/
module.yaml
agents/
workflows/
tools/
templates/
...
```
- `agents/` - Agent definitions
- `workflows/` - Workflow definitions
- Additional custom folders are supported but following conventions is recommended for agent and workflow discovery
**Note:** Full documentation for global modules and add-on modules will be available as support is finalized.
### Standalone Content (Agents, Workflows, Tasks, Tools, Templates, Prompts)
For standalone content that isn't part of a cohesive module collection, follow this structure:
1. **Module Configuration**
- Create a folder with a `module.yaml` file (similar to custom modules)
- Add the property `unitary: true` in the module.yaml
- The `unitary: true` property indicates this is a collection of potentially unrelated items that don't depend on each other
- Any content you add to this folder should still be nested under workflows and agents - but the key with stand alone content is they do not rely on each other.
- Agents do not reference other workflows even if stored in a unitary:true module. But unitary Agents can have their own workflows in their sidecar, or reference workflows as requirements from other modules - with a process known as workflow vendoring. Keep in mind, this will require that the workflow referenced from the other module would need to be available for the end user to install, so its recommended to only vendor workflows from the core module, or official bmm modules (See [Workflow Vendoring, Customization, and Inheritance](workflow-vendoring-customization-inheritance.md)).
2. **Folder Structure**
Organize content in specific named folders:
```
module-name/
module.yaml # Contains unitary: true
agents/
workflows/
templates/
tools/
tasks/
prompts/
```
3. **Individual Item Organization**
Each item should have its own subfolder:
```text
my-custom-stuff/
module.yaml
agents/
larry/larry.agent.md
curly/curly.agent.md
moe/moe.agent.md
moe/moe-sidecar/memories.csv
```
**Future Feature:** Unitary modules will support selective installation, allowing users to pick and choose which specific items to install.
**Note:** Documentation explaining the distinctions between these content types and their specific use cases will be available soon.
## Installation Process
### Prerequisites
Ensure your content follows the proper conventions and includes a `module.yaml` file (only one per top-level folder).
### New Project Installation
When setting up a new BMAD project:
1. The installer will prompt: `Would you like to install a local custom module (this includes custom agents and workflows also)? (y/N)`
2. Select 'y' to specify the path to your module folder containing `module.yaml`
### Existing Project Modification
To add custom content to an existing BMAD project:
1. Run the installer against your project location
2. Select `Modify BMAD Installation`
3. Choose the option to add, modify, or update custom modules
### Upcoming Features
- **Unitary Module Selection:** For modules with `type: unitary` (instead of `type: module`), you'll be able to select specific items to install
- **Add-on Module Dependencies:** The installer will verify and install dependencies for add-on modules automatically
## Quick Updates
When updates to BMAD Core or core modules (BMM, CIS, etc.) become available, the quick update process will:
1. Apply available updates to core modules
2. Recompile all agents with customizations from the `_config/agents` folder
3. Retain your custom content from a cached location
4. Preserve your existing configurations and customizations
This means you don't need to keep the source module files locally. When updates are available, simply point to the updated module location during the update process.
## Important Considerations
### Module Naming Conflicts
When installing unofficial modules, ensure unique identification to avoid conflicts:
1. **Module Codes:** Each module must have a unique code (e.g., don't use `bmm` for custom modules)
2. **Module Names:** Avoid using names that conflict with existing modules
3. **Multiple Custom Modules:** If creating multiple custom modules, use distinct codes for each
**Examples of conflicts to avoid:**
- Don't create a custom module with code `bmm` (already used by BMad Method)
- Don't name multiple custom modules with the same code like `mca`
### Best Practices
- Use descriptive, unique codes for your modules
- Document any dependencies your custom modules have
- Test custom modules in isolation before sharing
- Consider version numbering for your custom content to track updates

121
docs/modules/bmb-bmad-builder/custom-content.md Normal file
View File

@@ -0,0 +1,121 @@
# Custom Content
BMAD supports several categories of officially supported custom content that extend the platform's capabilities. Custom content can be created manually or with the recommended assistance of the BMad Builder (BoMB) Module. The BoMB Agents provides workflows and expertise to plan and build any custom content you can imagine.
This flexibility transforms the platform beyond its current capabilities, enabling:
- Extensions and add-ons for existing modules (BMad Method, Creative Intelligence Suite)
- Completely new modules, workflows, templates, and agents outside software engineering
- Professional services tools
- Entertainment and educational content
- Science and engineering workflows
- Productivity and self-help solutions
- Role-specific augmentation for virtually any profession
## Categories
- [Custom Content](#custom-content)
- [Categories](#categories)
- [Custom Stand Alone Modules](#custom-stand-alone-modules)
- [Custom Add On Modules](#custom-add-on-modules)
- [Custom Global Modules](#custom-global-modules)
- [Custom Agents](#custom-agents)
- [BMad Tiny Agents](#bmad-tiny-agents)
- [Simple and Expert Agents](#simple-and-expert-agents)
- [Custom Workflows](#custom-workflows)
## Custom Stand Alone Modules
Custom modules range from simple collections of related agents, workflows, and tools designed to work independently, to complex, expansive systems like the BMad Method or even larger applications.
Custom modules are [installable](./custom-content-installation.md) using the standard BMAD method and support advanced features:
- Optional user information collection during installation/updates
- Versioning and upgrade paths
- Custom installer functions with IDE-specific post-installation handling (custom hooks, subagents, or vendor-specific tools)
- Ability to bundle specific tools such as MCP, skills, execution libraries, and code
## Custom Add On Modules
Custom Add On Modules contain specific agents, tools, or workflows that expand, modify, or customize another module but cannot exist or install independently. These add-ons provide enhanced functionality while leveraging the base module's existing capabilities.
Examples include:
- Alternative implementation workflows for BMad Method agents
- Framework-specific support for particular use cases
- Game development expansions that add new genre-specific capabilities without reinventing existing functionality
Add on modules can include:
- Custom agents with awareness of the target module
- Access to existing module workflows
- Tool-specific features such as rulesets, hooks, subprocess prompts, subagents, and more
## Custom Global Modules
Similar to Custom Stand Alone Modules, but designed to add functionality that applies across all installed content. These modules provide cross-cutting capabilities that enhance the entire BMAD ecosystem.
Examples include:
- The current TTS (Text-to-Speech) functionality for Claude, which will soon be converted to a global module
- The core module, which is always installed and provides all agents with party mode and advanced elicitation capabilities
- Installation and update tools that work with any BMAD method configuration
Upcoming standards will document best practices for building global content that affects installed modules through:
- Custom content injections
- Agent customization auto-injection
- Tooling installers
## Custom Agents
Custom Agents can be designed and built for various use cases, from one-off specialized agents to more generic standalone solutions.
### BMad Tiny Agents
Personal agents designed for highly specific needs that may not be suitable for sharing. For example, a team management agent living in an Obsidian vault that helps with:
- Team coordination and management
- Understanding team details and requirements
- Tracking specific tasks with designated tools
These are simple, standalone files that can be scoped to focus on specific data or paths when integrated into an information vault or repository.
### Simple and Expert Agents
The distinction between simple and expert agents lies in their structure:
**Simple Agent:**
- Single file containing all prompts and configuration
- Self-contained and straightforward
**Expert Agent:**
- Similar to simple agents but includes a sidecar folder
- Sidecar folder contains additional resources: custom prompt files, scripts, templates, and memory files
- When installed, the sidecar folder (`[agentname]-sidecar`) is placed in the user memory location
- has metadata type: expert
The key distinction is the presence of a sidecar folder. As web and consumer agent tools evolve to support common memory mechanisms, storage formats, and MCP, the writable memory files will adapt to support these evolving standards.
Custom agents can be:
- Used within custom modules
- Designed as standalone tools
- Integrated with existing workflows and systems, if this is to be the case, should also include a module: <module name> if a specific module is intended for it to require working with
## Custom Workflows
Workflows are powerful, progressively loading sequence engines capable of performing tasks ranging from simple to complex, including:
- User engagements
- Business processes
- Content generation (code, documentation, or other output formats)
A custom workflow created outside of a larger module can still be distributed and used without associated agents through:
- Slash commands
- Manual command/prompt execution when supported by tools
At its core, a custom workflow is a single or series of prompts designed to achieve a specific outcome.

55
docs/modules/bmb-bmad-builder/index.md Normal file
View File

@@ -0,0 +1,55 @@
# BMB Module Documentation
Reference documentation for building BMAD agents and workflows.
## Agent Architecture
Comprehensive guides for each agent type (choose based on use case):
- [Understanding Agent Types](./understanding-agent-types.md) - **START HERE** - Architecture vs capability, "The Same Agent, Three Ways"
- [Simple Agent Architecture](./simple-agent-architecture.md) - Self-contained, optimized, personality-driven
- [Expert Agent Architecture](./expert-agent-architecture.md) - Memory, sidecar files, domain restrictions
- Module Agent Architecture _(TODO)_ - Workflow integration, professional tools
## Agent Design Patterns
- [Agent Menu Patterns](./agent-menu-patterns.md) - Menu handlers, triggers, prompts, organization
- [Agent Compilation](./agent-compilation.md) - What compiler auto-injects (AVOID DUPLICATION)
## Reference Examples
Production-ready examples in [bmb/reference/agents/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents):
**Simple Agents** ([simple-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/simple-examples))
- [commit-poet.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/simple-examples/commit-poet.agent.yaml) - Commit message artisan with style customization
**Expert Agents** ([expert-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples))
- [journal-keeper/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples/journal-keeper) - Personal journal companion with memory and pattern recognition
**Module Agents** ([module-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/module-examples))
- [security-engineer.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/module-examples/security-engineer.agent.yaml) - BMM security specialist with threat modeling
- [trend-analyst.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/module-examples/trend-analyst.agent.yaml) - CIS trend intelligence expert
## Installation Guide
For installing standalone simple and expert agents, see:
- [Custom Agent Installation](/docs/modules/bmb-bmad-builder/custom-content-installation.md)
## Key Concepts
### YAML to XML Compilation
Agents are authored in YAML with Handlebars templating. The compiler auto-injects:
1. **Frontmatter** - Name and description from metadata
2. **Activation Block** - Steps, menu handlers, rules (YOU don't write this)
3. **Menu Enhancement** - `*help` and `*exit` commands added automatically
4. **Trigger Prefixing** - Your triggers auto-prefixed with `*`
**Critical:** See [Agent Compilation](./agent-compilation.md) to avoid duplicating auto-injected content.
Source: `tools/cli/lib/agent/compiler.js`