bmad-method 1.0.1

package/tools/builders/web-builder.js

@@ -0,0 +1,145 @@
+const fs = require('fs').promises;
+const path = require('path');
+const DependencyResolver = require('../lib/dependency-resolver');
+
+class WebBuilder {
+  constructor(options = {}) {
+    this.rootDir = options.rootDir || process.cwd();
+    this.outputDirs = options.outputDirs || [
+      path.join(this.rootDir, 'dist'),
+      path.join(this.rootDir, '.bmad-core', 'web-bundles')
+    ];
+    this.resolver = new DependencyResolver(this.rootDir);
+    this.templatePath = path.join(this.rootDir, '.bmad-core', 'templates', 'web-agent-startup-instructions-template.md');
+  }
+
+  async cleanOutputDirs() {
+    for (const dir of this.outputDirs) {
+      try {
+        await fs.rm(dir, { recursive: true, force: true });
+        console.log(`Cleaned: ${path.relative(this.rootDir, dir)}`);
+      } catch (error) {
+        // Directory might not exist, that's fine
+      }
+    }
+  }
+
+  async buildAgents() {
+    const agents = await this.resolver.listAgents();
+    
+    for (const agentId of agents) {
+      console.log(`  Building agent: ${agentId}`);
+      const bundle = await this.buildAgentBundle(agentId);
+      
+      // Write to all output directories
+      for (const outputDir of this.outputDirs) {
+        const outputPath = path.join(outputDir, 'agents');
+        await fs.mkdir(outputPath, { recursive: true });
+        const outputFile = path.join(outputPath, `${agentId}.txt`);
+        await fs.writeFile(outputFile, bundle, 'utf8');
+      }
+    }
+
+    console.log(`Built ${agents.length} agent bundles in ${this.outputDirs.length} locations`);
+  }
+
+  async buildTeams() {
+    const teams = await this.resolver.listTeams();
+    
+    for (const teamId of teams) {
+      console.log(`  Building team: ${teamId}`);
+      const bundle = await this.buildTeamBundle(teamId);
+      
+      // Write to all output directories
+      for (const outputDir of this.outputDirs) {
+        const outputPath = path.join(outputDir, 'teams');
+        await fs.mkdir(outputPath, { recursive: true });
+        const outputFile = path.join(outputPath, `${teamId}.txt`);
+        await fs.writeFile(outputFile, bundle, 'utf8');
+      }
+    }
+
+    console.log(`Built ${teams.length} team bundles in ${this.outputDirs.length} locations`);
+  }
+
+  async buildAgentBundle(agentId) {
+    const dependencies = await this.resolver.resolveAgentDependencies(agentId);
+    const template = await fs.readFile(this.templatePath, 'utf8');
+    
+    const sections = [template];
+    
+    // Add agent configuration
+    sections.push(this.formatSection(dependencies.agent.path, dependencies.agent.content));
+    
+    // Add all dependencies
+    for (const resource of dependencies.resources) {
+      sections.push(this.formatSection(resource.path, resource.content));
+    }
+    
+    return sections.join('\n');
+  }
+
+  async buildTeamBundle(teamId) {
+    const dependencies = await this.resolver.resolveTeamDependencies(teamId);
+    const template = await fs.readFile(this.templatePath, 'utf8');
+    
+    const sections = [template];
+    
+    // Add team configuration
+    sections.push(this.formatSection(dependencies.team.path, dependencies.team.content));
+    
+    // Add all agents
+    for (const agent of dependencies.agents) {
+      sections.push(this.formatSection(agent.path, agent.content));
+    }
+    
+    // Add all deduplicated resources
+    for (const resource of dependencies.resources) {
+      sections.push(this.formatSection(resource.path, resource.content));
+    }
+    
+    return sections.join('\n');
+  }
+
+  formatSection(path, content) {
+    const separator = '====================';
+    return [
+      `${separator} START: ${path} ${separator}`,
+      content.trim(),
+      `${separator} END: ${path} ${separator}`,
+      ''
+    ].join('\n');
+  }
+
+  async validate() {
+    console.log('Validating agent configurations...');
+    const agents = await this.resolver.listAgents();
+    for (const agentId of agents) {
+      try {
+        await this.resolver.resolveAgentDependencies(agentId);
+        console.log(`  ✓ ${agentId}`);
+      } catch (error) {
+        console.log(`  ✗ ${agentId}: ${error.message}`);
+        throw error;
+      }
+    }
+
+    console.log('\nValidating team configurations...');
+    const teams = await this.resolver.listTeams();
+    for (const teamId of teams) {
+      try {
+        await this.resolver.resolveTeamDependencies(teamId);
+        console.log(`  ✓ ${teamId}`);
+      } catch (error) {
+        console.log(`  ✗ ${teamId}: ${error.message}`);
+        throw error;
+      }
+    }
+  }
+
+  listAgents() {
+    return this.resolver.listAgents();
+  }
+}
+
+module.exports = WebBuilder;

package/tools/cli.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const WebBuilder = require('./builders/web-builder');
+const V3ToV4Upgrader = require('./upgraders/v3-to-v4-upgrader');
+const IdeSetup = require('./installer/lib/ide-setup');
+const path = require('path');
+
+const program = new Command();
+
+program
+  .name('bmad-build')
+  .description('BMAD-METHOD build tool for creating web bundles')
+  .version('4.0.0');
+
+program
+  .command('build')
+  .description('Build web bundles for agents and teams')
+  .option('-a, --agents-only', 'Build only agent bundles')
+  .option('-t, --teams-only', 'Build only team bundles')
+  .option('--no-clean', 'Skip cleaning output directories')
+  .action(async (options) => {
+    const builder = new WebBuilder({
+      rootDir: process.cwd()
+    });
+
+    try {
+      if (options.clean) {
+        console.log('Cleaning output directories...');
+        await builder.cleanOutputDirs();
+      }
+
+      if (!options.teamsOnly) {
+        console.log('Building agent bundles...');
+        await builder.buildAgents();
+      }
+
+      if (!options.agentsOnly) {
+        console.log('Building team bundles...');
+        await builder.buildTeams();
+      }
+
+      // Generate IDE configuration folders
+      console.log('Generating IDE configuration folders...');
+      const installDir = process.cwd();
+      
+      // Generate configurations for all supported IDEs
+      const ides = ['cursor', 'claude-code', 'windsurf', 'roo'];
+      for (const ide of ides) {
+        try {
+          console.log(`Setting up ${ide} integration...`);
+          await IdeSetup.setup(ide, installDir);
+        } catch (error) {
+          console.warn(`Warning: Failed to setup ${ide}:`, error.message);
+        }
+      }
+
+      console.log('Build completed successfully!');
+    } catch (error) {
+      console.error('Build failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list:agents')
+  .description('List all available agents')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    const agents = await builder.resolver.listAgents();
+    console.log('Available agents:');
+    agents.forEach(agent => console.log(`  - ${agent}`));
+  });
+
+program
+  .command('validate')
+  .description('Validate agent and team configurations')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    try {
+      // Validate by attempting to build all agents and teams
+      const agents = await builder.resolver.listAgents();
+      const teams = await builder.resolver.listTeams();
+      
+      console.log('Validating agents...');
+      for (const agent of agents) {
+        await builder.resolver.resolveAgentDependencies(agent);
+        console.log(`  ✓ ${agent}`);
+      }
+      
+      console.log('\nValidating teams...');
+      for (const team of teams) {
+        await builder.resolver.resolveTeamDependencies(team);
+        console.log(`  ✓ ${team}`);
+      }
+      
+      console.log('\nAll configurations are valid!');
+    } catch (error) {
+      console.error('Validation failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('upgrade')
+  .description('Upgrade a BMAD-METHOD V3 project to V4')
+  .option('-p, --project <path>', 'Path to V3 project (defaults to current directory)')
+  .option('--dry-run', 'Show what would be changed without making changes')
+  .option('--no-backup', 'Skip creating backup (not recommended)')
+  .action(async (options) => {
+    const upgrader = new V3ToV4Upgrader();
+    await upgrader.upgrade({
+      projectPath: options.project,
+      dryRun: options.dryRun,
+      backup: options.backup
+    });
+  });
+
+program.parse();

package/tools/installer/README.md

@@ -0,0 +1,58 @@
+# BMAD Method Installer
+
+This directory contains the BMAD Method installer implementation.
+
+## Structure
+
+```text
+installer/
+├── bin/              # CLI entry points
+│   └── bmad.js      # Main CLI executable
+├── lib/             # Core implementation
+│   ├── installer.js # Main installation logic
+│   ├── updater.js   # Update management
+│   ├── config-loader.js # YAML config parsing
+│   ├── file-manager.js  # File operations
+│   ├── ide-setup.js     # IDE-specific setup
+│   └── prompts.js       # Interactive CLI prompts
+├── config/          # Configuration files
+│   └── install.config.yml # Installation profiles
+├── templates/       # IDE template files
+│   ├── cursor-rules.md     # Cursor template
+│   ├── claude-commands.md  # Claude Code template
+│   └── windsurf-rules.md   # Windsurf template
+└── package.json     # NPM package configuration
+```
+
+## Installation Profiles
+
+- **minimal**: IDE agents only (best for beginners)
+- **core**: IDE + Web agents
+- **teams**: Full team workflows
+- **developer**: Everything including creation tools
+
+## Usage
+
+````bash
+# Interactive installation
+npx bmad-method install
+
+# Direct profile installation
+npx bmad-method install --profile=minimal
+
+# Update existing installation
+npx bmad-method update
+```text
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Lint code
+npm run lint
+````

package/tools/installer/bin/bmad.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const path = require('path');
+
+// Handle both execution contexts (from root via npx or from installer directory)
+let version, installer;
+try {
+  // Try installer context first (when run from tools/installer/)
+  version = require('../package.json').version;
+  installer = require('../lib/installer');
+} catch (e) {
+  // Fall back to root context (when run via npx from GitHub)
+  try {
+    version = require('../../../package.json').version;
+    installer = require('../../../tools/installer/lib/installer');
+  } catch (e2) {
+    console.error(chalk.red('Error: Could not load required modules. Please ensure you are running from the correct directory.'));
+    console.error(chalk.yellow('Debug info:'), {
+      __dirname,
+      cwd: process.cwd(),
+      error: e2.message
+    });
+    process.exit(1);
+  }
+}
+
+program
+  .version(version)
+  .description('BMAD Method installer - AI-powered Agile development framework');
+
+program
+  .command('install')
+  .description('Install BMAD Method agents and tools')
+  .option('-f, --full', 'Install complete .bmad-core folder')
+  .option('-a, --agent <agent>', 'Install specific agent with dependencies')
+  .option('-d, --directory <path>', 'Installation directory (default: ./bmad-core)')
+  .option('-i, --ide <ide>', 'Configure for specific IDE (cursor, claude-code, windsurf, roo)')
+  .action(async (options) => {
+    try {
+      if (!options.full && !options.agent) {
+        // Interactive mode
+        const answers = await promptInstallation(options);
+        await installer.install(answers);
+      } else {
+        // Direct mode
+        const config = {
+          installType: options.full ? 'full' : 'single-agent',
+          agent: options.agent,
+          directory: options.directory || './.bmad-core',
+          ide: options.ide
+        };
+        await installer.install(config);
+      }
+    } catch (error) {
+      console.error(chalk.red('Installation failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('update')
+  .description('Update existing BMAD installation')
+  .option('--force', 'Force update, overwriting modified files')
+  .option('--dry-run', 'Show what would be updated without making changes')
+  .action(async (options) => {
+    try {
+      await installer.update(options);
+    } catch (error) {
+      console.error(chalk.red('Update failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list')
+  .description('List available agents')
+  .action(async () => {
+    try {
+      await installer.listAgents();
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Show installation status')
+  .action(async () => {
+    try {
+      await installer.showStatus();
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+async function promptInstallation(options) {
+  console.log(chalk.bold.blue(`\nWelcome to BMAD Method Installer v${version}\n`));
+  
+  const answers = {};
+  
+  // Ask for installation directory
+  const { directory } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'directory',
+      message: 'Where would you like to install BMAD?',
+      default: './.bmad-core'
+    }
+  ]);
+  answers.directory = directory;
+  
+  // Ask for installation type
+  const { installType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'installType',
+      message: 'How would you like to install BMAD?',
+      choices: [
+        {
+          name: 'Complete installation (recommended) - All agents and tools',
+          value: 'full'
+        },
+        {
+          name: 'Single agent - Choose one agent to install',
+          value: 'single-agent'
+        }
+      ]
+    }
+  ]);
+  answers.installType = installType;
+  
+  // If single agent, ask which one
+  if (installType === 'single-agent') {
+    const agents = await installer.getAvailableAgents();
+    const { agent } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'agent',
+        message: 'Select an agent to install:',
+        choices: agents.map(a => ({
+          name: `${a.id} - ${a.name} (${a.description})`,
+          value: a.id
+        }))
+      }
+    ]);
+    answers.agent = agent;
+  }
+  
+  // Ask for IDE configuration
+  const { ide } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'ide',
+      message: 'Which IDE are you using?',
+      choices: [
+        { name: 'Cursor', value: 'cursor' },
+        { name: 'Claude Code', value: 'claude-code' },
+        { name: 'Windsurf', value: 'windsurf' },
+        { name: 'Roo Code', value: 'roo' },
+        { name: 'Other/Manual setup', value: null }
+      ]
+    }
+  ]);
+  answers.ide = ide;
+  
+  return answers;
+}
+
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/tools/installer/config/install.config.yml

@@ -0,0 +1,139 @@
+installation-options:
+  full:
+    name: Complete BMAD Core
+    description: Copy the entire .bmad-core folder with all agents, templates, and tools
+    action: copy-folder
+    source: .bmad-core
+  single-agent:
+    name: Single Agent
+    description: Select and install a single agent with its dependencies
+    action: copy-agent
+agent-dependencies:
+  core-files:
+    - .bmad-core/utils/template-format.md
+  dev:
+    - .bmad-core/templates/story-tmpl.md
+    - .bmad-core/checklists/story-dod-checklist.md
+  pm:
+    - .bmad-core/templates/prd-tmpl.md
+    - .bmad-core/templates/brownfield-prd-tmpl.md
+    - .bmad-core/checklists/pm-checklist.md
+    - .bmad-core/checklists/change-checklist.md
+    - .bmad-core/tasks/advanced-elicitation.md
+    - .bmad-core/tasks/create-doc.md
+    - .bmad-core/tasks/correct-course.md
+    - .bmad-core/tasks/create-deep-research-prompt.md
+    - .bmad-core/tasks/brownfield-create-epic.md
+    - .bmad-core/tasks/brownfield-create-story.md
+    - .bmad-core/tasks/execute-checklist.md
+    - .bmad-core/tasks/shard-doc.md
+  architect:
+    - .bmad-core/templates/architecture-tmpl.md
+    - .bmad-core/checklists/architect-checklist.md
+  sm:
+    - .bmad-core/templates/story-tmpl.md
+    - .bmad-core/checklists/story-draft-checklist.md
+    - .bmad-core/workflows/*.yml
+  po:
+    - .bmad-core/checklists/po-master-checklist.md
+    - .bmad-core/templates/acceptance-criteria-tmpl.md
+  analyst:
+    - .bmad-core/templates/prd-tmpl.md
+    - .bmad-core/tasks/advanced-elicitation.md
+  qa:
+    - .bmad-core/checklists/story-dod-checklist.md
+    - .bmad-core/templates/test-plan-tmpl.md
+  ux-expert:
+    - .bmad-core/templates/ux-tmpl.md
+  bmad-master:
+    - .bmad-core/templates/*.md
+    - .bmad-core/tasks/*.md
+    - .bmad-core/schemas/*.yml
+  bmad-orchestrator:
+    - .bmad-core/agent-teams/*.yml
+    - .bmad-core/workflows/*.yml
+ide-configurations:
+  cursor:
+    name: Cursor
+    rule-dir: .cursor/rules/
+    format: multi-file
+    command-suffix: .mdc
+    instructions: |
+      # To use BMAD agents in Cursor:
+      # 1. Press Ctrl+L (Cmd+L on Mac) to open the chat
+      # 2. Type @agent-name (e.g., "@dev", "@pm", "@architect")
+      # 3. The agent will adopt that persona for the conversation
+  claude-code:
+    name: Claude Code
+    rule-dir: .claude/commands/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMAD agents in Claude Code:
+      # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
+      # 2. Claude will switch to that agent's persona
+  windsurf:
+    name: Windsurf
+    rule-dir: .windsurf/rules/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMAD agents in Windsurf:
+      # 1. Type @agent-name (e.g., "@dev", "@pm")
+      # 2. Windsurf will adopt that agent's persona
+  roo:
+    name: Roo Code
+    format: custom-modes
+    file: .roomodes
+    instructions: |
+      # To use BMAD agents in Roo Code:
+      # 1. Open the mode selector (usually in the status bar)
+      # 2. Select any bmad-{agent} mode (e.g., "bmad-dev", "bmad-pm")
+      # 3. The AI will adopt that agent's full personality and capabilities
+  cline:
+    name: Cline
+    format: unknown
+    instructions: |
+      # Cline configuration coming soon
+      # Manual setup: Copy IDE agent files to your Cline configuration
+available-agents:
+  - id: analyst
+    name: Business Analyst
+    file: .bmad-core/agents/analyst.md
+    description: Requirements gathering and analysis
+  - id: pm
+    name: Product Manager
+    file: .bmad-core/agents/pm.md
+    description: Product strategy and roadmap planning
+  - id: architect
+    name: Solution Architect
+    file: .bmad-core/agents/architect.md
+    description: Technical design and architecture
+  - id: po
+    name: Product Owner
+    file: .bmad-core/agents/po.md
+    description: Backlog management and prioritization
+  - id: sm
+    name: Scrum Master
+    file: .bmad-core/agents/sm.md
+    description: Agile process and story creation
+  - id: dev
+    name: Developer
+    file: .bmad-core/agents/dev.md
+    description: Code implementation and testing
+  - id: qa
+    name: QA Engineer
+    file: .bmad-core/agents/qa.md
+    description: Quality assurance and testing
+  - id: ux-expert
+    name: UX Expert
+    file: .bmad-core/agents/ux-expert.md
+    description: User experience design
+  - id: bmad-master
+    name: BMAD Master
+    file: .bmad-core/agents/bmad-master.md
+    description: BMAD framework expert and guide
+  - id: bmad-orchestrator
+    name: BMAD Orchestrator
+    file: .bmad-core/agents/bmad-orchestrator.md
+    description: Multi-agent workflow coordinator