create-byan-agent 2.1.0 → 2.1.1

package/_bmad/bmb/workflows/module/data/agent-architecture.md

@@ -1,179 +0,0 @@
-# Agent Architecture for Modules
-
-**Purpose:** High-level guidance for planning agents in your module — not implementation details (that's what the agent-builder workflow is for).
-
----
-
-## Single Agent vs. Multi-Agent Module
-
-### Single Agent Module
-
-**Use when:** One persona can handle the module's purpose.
-
-**Characteristics:**
-- Simpler, focused
-- Clear single point of contact
-- Good for narrow domains
-
-**Question:** Could one expert agent with a sidecar handle this entire module?
-
----
-
-### Multi-Agent Module
-
-**Use when:** Different expertise areas justify specialized personas.
-
-**Characteristics:**
-- Each agent has a distinct role and expertise
-- Agents form a cohesive team around the module's theme
-- Menus coordinate to guide users to the right agent
-
-**Why multi-agent?**
-- Different workflows need different expert perspectives
-- Users expect to talk to "the right expert" for each task
-- The module covers a domain too broad for one persona
-
----
-
-## Flagship Example: BMM Agent Team
-
-BMM demonstrates a multi-agent module with **9 specialized agents** forming a complete software development team.
-
-### The BMM Theme
-
-**"Agile software delivery, AI-driven"**
-
-Every agent serves this theme — they're a complete team working together.
-
-### BMM Agent Overview
-
-| Agent | Name | Role | Responsible For |
-|-------|------|------|-----------------|
-| PM | John | Product Manager | PRDs, requirements, user stories |
-| Architect | Winston | System Architect | Technical design, architecture |
-| UX | | UX Designer | User research, UX design |
-| Dev | | Developer | Implementation, coding |
-| TEA | | Test Engineer Architect | Test architecture, QA |
-| SM | | Scrum Master | Sprint planning, workflow status |
-| Tech Writer | | Technical Writer | Documentation |
-| Analyst | | Business Analyst | Analysis, metrics |
-| Quick Flow | | Solo Developer | Quick standalone work |
-
-### Key Patterns
-
-1. **Shared commands** — All agents have `[WS]` Workflow Status
-2. **Specialty commands** — Each agent has unique commands (PM→PRD, Architect→Architecture)
-3. **No overlap** — Each command has one clear owner
-4. **Collaboration** — Agents reference each other's work (PRD → Architecture → Implementation)
-
----
-
-## Planning Your Agents
-
-### For Each Agent, Document:
-
-1. **Role** — What is this agent responsible for?
-2. **Workflows** — Which workflows will this agent trigger/own?
-3. **Human Name** — What's their persona name? (e.g., "John", "Winston")
-4. **Communication Style** — How do they talk? (e.g., "Direct and data-sharp", "Calm and pragmatic")
-5. **Skills/Expertise** — What knowledge does this agent bring?
-6. **Memory/Learning** — Does this agent need to remember things over time? (hasSidecar)
-
-That's it! The agent-builder workflow will handle the detailed implementation.
-
----
-
-## Agent Memory & Learning
-
-### Sidecar Agents (hasSidecar: true)
-
-**Use when:** The agent needs to remember context across sessions.
-
-**Characteristics:**
-- Has a sidecar file that persists between conversations
-- Learns from user interactions
-- Remembers project details, preferences, past work
-
-**Examples:**
-- An agent that tracks project decisions over time
-- An agent that learns user preferences
-- An agent that maintains ongoing project context
-
-### Stateless Agents (hasSidecar: false)
-
-**Use when:** The agent doesn't need persistent memory.
-
-**Characteristics:**
-- Each conversation starts fresh
-- Relies on shared context files (like project-context.md)
-- Simpler, more predictable
-
-**Most module agents are stateless** — they reference shared project context rather than maintaining their own memory.
-
----
-
-## Agent-Workflow Coordination
-
-### Menu Triggers
-
-Each agent has menu items that trigger workflows:
-
-| Trigger Type | Pattern | Example |
-|--------------|---------|---------|
-| Shared | Same across all agents | `[WS]` Workflow Status |
-| Specialty | Unique to this agent | `[PR]` Create PRD (PM only) |
-| Cross-reference | Points to another agent's workflow | "See architecture" |
-
-### Simple Planning Format
-
-For each agent, just document:
-
-```
-Agent: PM (John)
-Role: Product Manager, requirements, PRDs
-Triggers:
-  - WS → Workflow Status (shared)
-  - PR → Create PRD (specialty)
-  - ES → Epics and Stories (specialty)
-Memory: No (uses shared project-context)
-```
-
-The agent-builder workflow will convert this into the proper format.
-
----
-
-## When to Use Multiple Agents
-
-**Consider multiple agents when:**
-- Different workflows require different expertise
-- The domain has clear specialization areas
-- Users would expect to talk to different "experts"
-- The module covers a broad process (like software development)
-
-**Use a single agent when:**
-- The domain is focused and narrow
-- One expertise area covers all workflows
-- Simplicity is preferred
-- The agent could reasonably handle everything with a sidecar
-
----
-
-## Quick Agent Planning Checklist
-
-For each agent in your module:
-
-- [ ] Role defined (what they're responsible for)
-- [ ] Workflows assigned (which workflows they trigger)
-- [ ] Human name chosen (persona)
-- [ ] Communication style described
-- [ ] Skills/expertise identified
-- [ ] Memory decision (hasSidecar: true/false)
-
----
-
-## Notes
-
-- **Don't worry about the exact YAML format** — agent-builder handles that
-- **Focus on the planning** — who does what, how they work together
-- **Keep it high-level** — this is about the module's agent architecture, not implementation details
-- **BMM is the reference** — look at how their agents form a cohesive team

package/_bmad/bmb/workflows/module/data/agent-spec-template.md

@@ -1,79 +0,0 @@
-# Agent Specification: {agent_name}
-
-**Module:** {module_code}
-**Status:** Placeholder — To be created via create-agent workflow
-**Created:** {date}
-
----
-
-## Agent Metadata
-
-```yaml
-agent:
-  metadata:
-    id: "_bmad/{module_code}/agents/{agent_file_name}.md"
-    name: {agent_human_name}
-    title: {agent_title}
-    icon: {agent_icon}
-    module: {module_code}
-    hasSidecar: false
-```
-
----
-
-## Agent Persona
-
-### Role
-
-{agent_role}
-
-### Identity
-
-{agent_identity}
-
-### Communication Style
-
-{agent_communication_style}
-
-### Principles
-
-{agent_principles}
-
----
-
-## Agent Menu
-
-### Planned Commands
-
-| Trigger | Command | Description | Workflow |
-|---------|---------|-------------|----------|
-{agent_menu_table}
-
----
-
-## Agent Integration
-
-### Shared Context
-
-- References: `{shared_context_files}`
-- Collaboration with: {collaborating_agents}
-
-### Workflow References
-
-{workflow_references}
-
----
-
-## Implementation Notes
-
-**Use the create-agent workflow to build this agent.**
-
-Inputs needed:
-- Agent name and human name
-- Role and expertise area
-- Communication style preferences
-- Menu commands and workflow mappings
-
----
-
-_Spec created on {date} via BMAD Module workflow_

package/_bmad/bmb/workflows/module/data/module-installer-standards.md

@@ -1,348 +0,0 @@
-# Module Installer Standards
-
-**Purpose:** How the `_module-installer` folder works, including installer.js patterns and platform-specific configuration.
-
----
-
-## Overview
-
-The `_module-installer` folder contains optional installation logic for your module. It runs AFTER the IDE installations and can:
-- Create directories specified in module.yaml
-- Copy assets or templates
-- Configure IDE-specific settings
-- Set up platform-specific integrations
-
----
-
-## When Do You Need an Installer?
-
-### Use an Installer When:
-
-- Creating directories based on user configuration
-- Copying template files to the user's project
-- IDE-specific setup (Claude Code, Windsurf, Cursor, etc.)
-- Platform-specific integrations
-
-### Skip the Installer When:
-
-- Module only provides agents and workflows
-- No file operations needed
-- No IDE-specific configuration
-
----
-
-## Folder Structure
-
-```
-_module-installer/
-├── installer.js                 # Main installer (REQUIRED if folder exists)
-└── platform-specifics/          # IDE-specific handlers (optional)
-    ├── claude-code.js
-    ├── windsurf.js
-    ├── cursor.js
-    └── ...
-```
-
----
-
-## installer.js Pattern
-
-### Function Signature
-
-```javascript
-/**
- * Module Installer
- *
- * @param {Object} options - Installation options
- * @param {string} options.projectRoot - The root directory of the target project
- * @param {Object} options.config - Module configuration from module.yaml (resolved variables)
- * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
- * @param {Object} options.logger - Logger instance for output
- * @returns {Promise<boolean>} - Success status (true = success, false = failure)
- */
-async function install(options) {
-  const { projectRoot, config, installedIDEs, logger } = options;
-
-  try {
-    // Installation logic here
-    logger.log(chalk.blue('Installing {Module Name}...'));
-
-    // ... your logic ...
-
-    logger.log(chalk.green('✓ {Module Name} installation complete'));
-    return true;
-  } catch (error) {
-    logger.error(chalk.red(`Error installing module: ${error.message}`));
-    return false;
-  }
-}
-
-module.exports = { install };
-```
-
----
-
-### What You Receive
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `projectRoot` | string | Absolute path to the user's project root |
-| `config` | object | Resolved module.yaml variables |
-| `installedIDEs` | array | List of IDE codes installed (e.g., `['claude-code', 'windsurf']`) |
-| `logger` | object | Logger with `.log()`, `.warn()`, `.error()` methods |
-
-The `config` object contains your module.yaml variables **after** user input:
-
-```javascript
-// If module.yaml defined:
-// project_name:
-//   prompt: "What is your project name?"
-//   result: "{value}"
-
-config.project_name  // = user's input
-config.planning_artifacts  // = resolved path
-```
-
----
-
-## Common Installation Tasks
-
-### 1. Create Directories
-
-```javascript
-const fs = require('fs-extra');
-const path = require('node:path');
-
-// Create directory from config
-if (config['planning_artifacts']) {
-  const dirConfig = config['planning_artifacts'].replace('{project-root}/', '');
-  const dirPath = path.join(projectRoot, dirConfig);
-
-  if (!(await fs.pathExists(dirPath))) {
-    logger.log(chalk.yellow(`Creating directory: ${dirConfig}`));
-    await fs.ensureDir(dirPath);
-  }
-}
-```
-
-### 2. Copy Assets
-
-```javascript
-const assetsSource = path.join(__dirname, 'assets');
-const assetsDest = path.join(projectRoot, 'docs');
-
-if (await fs.pathExists(assetsSource)) {
-  await fs.copy(assetsSource, assetsDest);
-  logger.log(chalk.green('✓ Copied assets to docs/'));
-}
-```
-
-### 3. IDE-Specific Configuration
-
-```javascript
-// Handle IDE-specific configurations
-if (installedIDEs && installedIDEs.length > 0) {
-  logger.log(chalk.cyan(`Configuring for IDEs: ${installedIDEs.join(', ')}`));
-
-  for (const ide of installedIDEs) {
-    await configureForIDE(ide, projectRoot, config, logger);
-  }
-}
-```
-
----
-
-## Platform-Specific Handlers
-
-### Pattern
-
-Create files in `platform-specifics/{ide-code}.js`:
-
-```javascript
-// platform-specifics/claude-code.js
-
-/**
- * Configure module for Claude Code
- */
-async function install(options) {
-  const { projectRoot, config, logger, platformInfo } = options;
-
-  try {
-    // Claude Code specific configuration
-    logger.log(chalk.dim('  Configuring Claude Code integration...'));
-
-    // Your logic here
-
-    return true;
-  } catch (error) {
-    logger.warn(chalk.yellow(`  Warning: ${error.message}`));
-    return false;
-  }
-}
-
-module.exports = { install };
-```
-
-### Load from Main Installer
-
-```javascript
-// installer.js
-const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
-
-async function configureForIDE(ide, projectRoot, config, logger) {
-  // Validate platform code
-  if (!platformCodes.isValidPlatform(ide)) {
-    logger.warn(chalk.yellow(`  Unknown platform: '${ide}'. Skipping.`));
-    return;
-  }
-
-  const platformName = platformCodes.getDisplayName(ide);
-  const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
-
-  try {
-    if (await fs.pathExists(platformSpecificPath)) {
-      const platformHandler = require(platformSpecificPath);
-
-      if (typeof platformHandler.install === 'function') {
-        await platformHandler.install({ projectRoot, config, logger });
-        logger.log(chalk.green(`  ✓ Configured for ${platformName}`));
-      }
-    }
-  } catch (error) {
-    logger.warn(chalk.yellow(`  Warning: Could not configure ${platformName}: ${error.message}`));
-  }
-}
-```
-
----
-
-## Complete Example: BMM Installer
-
-```javascript
-const fs = require('fs-extra');
-const path = require('node:path');
-const chalk = require('chalk');
-const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
-
-/**
- * BMM Module Installer
- */
-async function install(options) {
-  const { projectRoot, config, installedIDEs, logger } = options;
-
-  try {
-    logger.log(chalk.blue('🚀 Installing BMM Module...'));
-
-    // Create output directory
-    if (config['output_folder']) {
-      const outputConfig = config['output_folder'].replace('{project-root}/', '');
-      const outputPath = path.join(projectRoot, outputConfig);
-      if (!(await fs.pathExists(outputPath))) {
-        logger.log(chalk.yellow(`Creating output directory: ${outputConfig}`));
-        await fs.ensureDir(outputPath);
-      }
-    }
-
-    // Create implementation artifacts directory
-    if (config['implementation_artifacts']) {
-      const storyConfig = config['implementation_artifacts'].replace('{project-root}/', '');
-      const storyPath = path.join(projectRoot, storyConfig);
-      if (!(await fs.pathExists(storyPath))) {
-        logger.log(chalk.yellow(`Creating story directory: ${storyConfig}`));
-        await fs.ensureDir(storyPath);
-      }
-    }
-
-    // IDE-specific configuration
-    if (installedIDEs && installedIDEs.length > 0) {
-      logger.log(chalk.cyan(`Configuring BMM for IDEs: ${installedIDEs.join(', ')}`));
-
-      for (const ide of installedIDEs) {
-        await configureForIDE(ide, projectRoot, config, logger);
-      }
-    }
-
-    logger.log(chalk.green('✓ BMM Module installation complete'));
-    return true;
-  } catch (error) {
-    logger.error(chalk.red(`Error installing BMM: ${error.message}`));
-    return false;
-  }
-}
-
-async function configureForIDE(ide, projectRoot, config, logger) {
-  if (!platformCodes.isValidPlatform(ide)) {
-    logger.warn(chalk.yellow(`  Warning: Unknown platform '${ide}'. Skipping.`));
-    return;
-  }
-
-  const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
-
-  try {
-    if (await fs.pathExists(platformSpecificPath)) {
-      const platformHandler = require(platformSpecificPath);
-
-      if (typeof platformHandler.install === 'function') {
-        await platformHandler.install({ projectRoot, config, logger });
-      }
-    }
-  } catch (error) {
-    logger.warn(chalk.yellow(`  Warning: Could not load handler for ${ide}: ${error.message}`));
-  }
-}
-
-module.exports = { install };
-```
-
----
-
-## Best Practices
-
-### DO:
-- Return `true` for success, `false` for failure
-- Use chalk for colored output
-- Log what you're doing (create, copy, configure)
-- Handle errors gracefully with try/catch
-- Validate paths before creating directories
-
-### DON'T:
-- Assume paths exist — check with `fs.pathExists()`
-- Overwrite user files without asking
-- Fail silently — log errors
-- Use absolute paths — build from `projectRoot`
-
----
-
-## Available Platform Codes
-
-Common IDE codes:
-- `claude-code` — Anthropic's Claude Code
-- `windsurf` — Windsurf IDE
-- `cursor` — Cursor AI IDE
-- `vscode` — Visual Studio Code
-
-Use `platformCodes.isValidPlatform(ide)` to validate.
-
----
-
-## Testing Your Installer
-
-1. Create a test project
-2. Run `bmad install {your-module}`
-3. Verify directories are created
-4. Check that config variables are resolved correctly
-5. Test platform-specific handlers
-
----
-
-## Quick Reference
-
-| Task | Code Pattern |
-|------|--------------|
-| Create directory | `await fs.ensureDir(path)` |
-| Check if exists | `await fs.pathExists(path)` |
-| Copy files | `await fs.copy(src, dest)` |
-| Log info | `logger.log(chalk.blue('message'))` |
-| Log success | `logger.log(chalk.green('✓ message'))` |
-| Log warning | `logger.warn(chalk.yellow('warning'))` |
-| Log error | `logger.error(chalk.red('error'))` |