bmad-method 5.1.2 → 6.0.0-alpha.0

package/tools/cli/installers/lib/ide/crush.js

@@ -0,0 +1,204 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Crush IDE setup handler
+ * Creates commands in .crush/commands/ directory structure
+ */
+class CrushSetup extends BaseIdeSetup {
+  constructor() {
+    super('crush', 'Crush');
+    this.configDir = '.crush';
+    this.commandsDir = 'commands';
+  }
+
+  /**
+   * Setup Crush IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Create .crush/commands/bmad directory structure
+    const crushDir = path.join(projectDir, this.configDir);
+    const commandsDir = path.join(crushDir, this.commandsDir, 'bmad');
+    const agentsDir = path.join(commandsDir, 'agents');
+    const tasksDir = path.join(commandsDir, 'tasks');
+
+    await this.ensureDir(agentsDir);
+    await this.ensureDir(tasksDir);
+
+    // Get agents and tasks
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir);
+
+    // Setup agents as commands
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readFile(agent.path);
+      const commandContent = this.createAgentCommand(agent, content, projectDir);
+
+      const targetPath = path.join(agentsDir, `${agent.module}-${agent.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+      agentCount++;
+    }
+
+    // Setup tasks as commands
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const commandContent = this.createTaskCommand(task, content);
+
+      const targetPath = path.join(tasksDir, `${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+      taskCount++;
+    }
+
+    // Create module-specific subdirectories for better organization
+    await this.organizeByModule(commandsDir, agents, tasks, bmadDir);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agent commands created`));
+    console.log(chalk.dim(`  - ${taskCount} task commands created`));
+    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
+    console.log(chalk.dim('\n  Commands can be accessed via Crush command palette'));
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+    };
+  }
+
+  /**
+   * Organize commands by module
+   */
+  async organizeByModule(commandsDir, agents, tasks, bmadDir) {
+    // Get unique modules
+    const modules = new Set();
+    for (const agent of agents) modules.add(agent.module);
+    for (const task of tasks) modules.add(task.module);
+
+    // Create module directories
+    for (const module of modules) {
+      const moduleDir = path.join(commandsDir, module);
+      const moduleAgentsDir = path.join(moduleDir, 'agents');
+      const moduleTasksDir = path.join(moduleDir, 'tasks');
+
+      await this.ensureDir(moduleAgentsDir);
+      await this.ensureDir(moduleTasksDir);
+
+      // Copy module-specific agents
+      const moduleAgents = agents.filter((a) => a.module === module);
+      for (const agent of moduleAgents) {
+        const content = await this.readFile(agent.path);
+        const commandContent = this.createAgentCommand(agent, content, bmadDir);
+        const targetPath = path.join(moduleAgentsDir, `${agent.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+      }
+
+      // Copy module-specific tasks
+      const moduleTasks = tasks.filter((t) => t.module === module);
+      for (const task of moduleTasks) {
+        const content = await this.readFile(task.path);
+        const commandContent = this.createTaskCommand(task, content);
+        const targetPath = path.join(moduleTasksDir, `${task.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+      }
+    }
+  }
+
+  /**
+   * Create agent command content
+   */
+  createAgentCommand(agent, content, projectDir) {
+    // Extract metadata
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    const iconMatch = content.match(/icon="([^"]+)"/);
+    const icon = iconMatch ? iconMatch[1] : '🤖';
+
+    // Get relative path
+    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
+
+    let commandContent = `# /${agent.name} Command
+
+When this command is used, adopt the following agent persona:
+
+## ${icon} ${title} Agent
+
+${content}
+
+## Command Usage
+
+This command activates the ${title} agent from the BMAD ${agent.module.toUpperCase()} module.
+
+## File Reference
+
+Complete agent definition: [${relativePath}](${relativePath})
+
+## Module
+
+Part of the BMAD ${agent.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Create task command content
+   */
+  createTaskCommand(task, content) {
+    // Extract task name
+    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    let commandContent = `# /task-${task.name} Command
+
+When this command is used, execute the following task:
+
+## ${taskName} Task
+
+${content}
+
+## Command Usage
+
+This command executes the ${taskName} task from the BMAD ${task.module.toUpperCase()} module.
+
+## Module
+
+Part of the BMAD ${task.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Crush configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, 'bmad');
+
+    if (await fs.pathExists(bmadCommandsDir)) {
+      await fs.remove(bmadCommandsDir);
+      console.log(chalk.dim(`Removed BMAD commands from Crush`));
+    }
+  }
+}
+
+module.exports = { CrushSetup };

package/tools/cli/installers/lib/ide/cursor.js

@@ -0,0 +1,224 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Cursor IDE setup handler
+ */
+class CursorSetup extends BaseIdeSetup {
+  constructor() {
+    super('cursor', 'Cursor', true); // preferred IDE
+    this.configDir = '.cursor';
+    this.rulesDir = 'rules';
+  }
+
+  /**
+   * Setup Cursor IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Create .cursor/rules directory structure
+    const cursorDir = path.join(projectDir, this.configDir);
+    const rulesDir = path.join(cursorDir, this.rulesDir);
+    const bmadRulesDir = path.join(rulesDir, 'bmad');
+
+    await this.ensureDir(bmadRulesDir);
+
+    // Get agents and tasks
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir);
+
+    // Create directories for each module
+    const modules = new Set();
+    for (const item of [...agents, ...tasks]) modules.add(item.module);
+
+    for (const module of modules) {
+      await this.ensureDir(path.join(bmadRulesDir, module));
+      await this.ensureDir(path.join(bmadRulesDir, module, 'agents'));
+      await this.ensureDir(path.join(bmadRulesDir, module, 'tasks'));
+    }
+
+    // Process and copy agents
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readAndProcess(agent.path, {
+        module: agent.module,
+        name: agent.name,
+      });
+
+      const targetPath = path.join(bmadRulesDir, agent.module, 'agents', `${agent.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      agentCount++;
+    }
+
+    // Process and copy tasks
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readAndProcess(task.path, {
+        module: task.module,
+        name: task.name,
+      });
+
+      const targetPath = path.join(bmadRulesDir, task.module, 'tasks', `${task.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      taskCount++;
+    }
+
+    // Create BMAD index file (but NOT .cursorrules - user manages that)
+    await this.createBMADIndex(bmadRulesDir, agents, tasks, modules);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents installed`));
+    console.log(chalk.dim(`  - ${taskCount} tasks installed`));
+    console.log(chalk.dim(`  - Rules directory: ${path.relative(projectDir, bmadRulesDir)}`));
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+    };
+  }
+
+  /**
+   * Create BMAD index file for easy navigation
+   */
+  async createBMADIndex(bmadRulesDir, agents, tasks, modules) {
+    const indexPath = path.join(bmadRulesDir, 'index.mdc');
+
+    let content = `---
+description: BMAD Method - Master Index
+globs: 
+alwaysApply: true
+---
+
+# BMAD Method - Cursor Rules Index
+
+This is the master index for all BMAD agents and tasks available in your project.
+
+## Installation Complete!
+
+BMAD rules have been installed to: \`.cursor/rules/bmad/\`
+
+**Note:** BMAD does not modify your \`.cursorrules\` file. You manage that separately.
+
+## How to Use
+
+- Reference specific agents: @bmad/{module}/agents/{agent-name}
+- Reference specific tasks: @bmad/{module}/tasks/{task-name}
+- Reference entire modules: @bmad/{module}
+- Reference this index: @bmad/index
+
+## Available Modules
+
+`;
+
+    for (const module of modules) {
+      content += `### ${module.toUpperCase()}\n\n`;
+
+      // List agents for this module
+      const moduleAgents = agents.filter((a) => a.module === module);
+      if (moduleAgents.length > 0) {
+        content += `**Agents:**\n`;
+        for (const agent of moduleAgents) {
+          content += `- @bmad/${module}/agents/${agent.name} - ${agent.name}\n`;
+        }
+        content += '\n';
+      }
+
+      // List tasks for this module
+      const moduleTasks = tasks.filter((t) => t.module === module);
+      if (moduleTasks.length > 0) {
+        content += `**Tasks:**\n`;
+        for (const task of moduleTasks) {
+          content += `- @bmad/${module}/tasks/${task.name} - ${task.name}\n`;
+        }
+        content += '\n';
+      }
+    }
+
+    content += `
+## Quick Reference
+
+- All BMAD rules are Manual type - reference them explicitly when needed
+- Agents provide persona-based assistance with specific expertise
+- Tasks are reusable workflows for common operations
+- Each agent includes an activation block for proper initialization
+
+## Configuration
+
+BMAD rules are configured as Manual rules (alwaysApply: false) to give you control
+over when they're included in your context. Reference them explicitly when you need
+specific agent expertise or task workflows.
+`;
+
+    await this.writeFile(indexPath, content);
+  }
+
+  /**
+   * Read and process file content
+   */
+  async readAndProcess(filePath, metadata) {
+    const fs = require('fs-extra');
+    const content = await fs.readFile(filePath, 'utf8');
+    return this.processContent(content, metadata);
+  }
+
+  /**
+   * Override processContent to add MDC metadata header for Cursor
+   * @param {string} content - File content
+   * @param {Object} metadata - File metadata
+   * @returns {string} Processed content with MDC header
+   */
+  processContent(content, metadata = {}) {
+    // First apply base processing (includes activation injection for agents)
+    let processed = super.processContent(content, metadata);
+
+    // Determine the type and description based on content
+    const isAgent = content.includes('<agent');
+    const isTask = content.includes('<task');
+
+    let description = '';
+    let globs = '';
+
+    if (isAgent) {
+      // Extract agent title if available
+      const titleMatch = content.match(/title="([^"]+)"/);
+      const title = titleMatch ? titleMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Agent: ${title}`;
+
+      // Manual rules for agents don't need globs
+      globs = '';
+    } else if (isTask) {
+      // Extract task name if available
+      const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+      const taskName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Task: ${taskName}`;
+
+      // Tasks might be auto-attached to certain file types
+      globs = '';
+    } else {
+      description = `BMAD ${metadata.module.toUpperCase()}: ${metadata.name}`;
+      globs = '';
+    }
+
+    // Create MDC metadata header
+    const mdcHeader = `---
+description: ${description}
+globs: ${globs}
+alwaysApply: false
+---
+
+`;
+
+    // Add the MDC header to the processed content
+    return mdcHeader + processed;
+  }
+}
+
+module.exports = { CursorSetup };

package/tools/cli/installers/lib/ide/gemini.js

@@ -0,0 +1,160 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Gemini CLI setup handler
+ * Creates TOML files in .gemini/commands/ structure
+ */
+class GeminiSetup extends BaseIdeSetup {
+  constructor() {
+    super('gemini', 'Gemini CLI', true); // preferred IDE
+    this.configDir = '.gemini';
+    this.commandsDir = 'commands';
+  }
+
+  /**
+   * Setup Gemini CLI configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Create .gemini/commands/agents and .gemini/commands/tasks directories
+    const geminiDir = path.join(projectDir, this.configDir);
+    const commandsDir = path.join(geminiDir, this.commandsDir);
+    const agentsDir = path.join(commandsDir, 'agents');
+    const tasksDir = path.join(commandsDir, 'tasks');
+
+    await this.ensureDir(agentsDir);
+    await this.ensureDir(tasksDir);
+
+    // Get agents and tasks
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir);
+
+    // Install agents as TOML files
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readFile(agent.path);
+      const tomlContent = this.createAgentToml(agent, content, bmadDir);
+
+      const tomlPath = path.join(agentsDir, `${agent.name}.toml`);
+      await this.writeFile(tomlPath, tomlContent);
+      agentCount++;
+
+      console.log(chalk.green(`  ✓ Added agent: /bmad:agents:${agent.name}`));
+    }
+
+    // Install tasks as TOML files
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const tomlContent = this.createTaskToml(task, content, bmadDir);
+
+      const tomlPath = path.join(tasksDir, `${task.name}.toml`);
+      await this.writeFile(tomlPath, tomlContent);
+      taskCount++;
+
+      console.log(chalk.green(`  ✓ Added task: /bmad:tasks:${task.name}`));
+    }
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents configured`));
+    console.log(chalk.dim(`  - ${taskCount} tasks configured`));
+    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
+    console.log(chalk.dim(`  - Agent activation: /bmad:agents:{agent-name}`));
+    console.log(chalk.dim(`  - Task activation: /bmad:tasks:{task-name}`));
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+    };
+  }
+
+  /**
+   * Create agent TOML content
+   */
+  createAgentToml(agent, content, bmadDir) {
+    // Extract metadata
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    // Get relative path from project root to agent file
+    const relativePath = path.relative(process.cwd(), agent.path).replaceAll('\\', '/');
+
+    // Create TOML content
+    const tomlContent = `description = "Activates the ${title} agent from the BMad Method."
+prompt = """
+CRITICAL: You are now the BMad '${title}' agent. Adopt its persona and capabilities as defined in the following configuration.
+
+Read and internalize the full agent definition, following all instructions and maintaining this persona until explicitly told to switch or exit.
+
+@${relativePath}
+"""
+`;
+
+    return tomlContent;
+  }
+
+  /**
+   * Create task TOML content
+   */
+  createTaskToml(task, content, bmadDir) {
+    // Extract task name from XML if available
+    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    // Get relative path from project root to task file
+    const relativePath = path.relative(process.cwd(), task.path).replaceAll('\\', '/');
+
+    // Create TOML content
+    const tomlContent = `description = "Executes the ${taskName} task from the BMad Method."
+prompt = """
+Execute the following BMad Method task workflow:
+
+@${relativePath}
+
+Follow all instructions and complete the task as defined.
+"""
+`;
+
+    return tomlContent;
+  }
+
+  /**
+   * Cleanup Gemini configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
+    const agentsDir = path.join(commandsDir, 'agents');
+    const tasksDir = path.join(commandsDir, 'tasks');
+
+    // Remove BMAD TOML files
+    if (await fs.pathExists(agentsDir)) {
+      const files = await fs.readdir(agentsDir);
+      for (const file of files) {
+        if (file.endsWith('.toml')) {
+          await fs.remove(path.join(agentsDir, file));
+        }
+      }
+    }
+
+    if (await fs.pathExists(tasksDir)) {
+      const files = await fs.readdir(tasksDir);
+      for (const file of files) {
+        if (file.endsWith('.toml')) {
+          await fs.remove(path.join(tasksDir, file));
+        }
+      }
+    }
+
+    console.log(chalk.dim(`Removed BMAD configuration from Gemini CLI`));
+  }
+}
+
+module.exports = { GeminiSetup };