bmad-method 5.1.3 → 6.0.0-alpha.1

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

@@ -0,0 +1,278 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Trae IDE setup handler
+ */
+class TraeSetup extends BaseIdeSetup {
+  constructor() {
+    super('trae', 'Trae');
+    this.configDir = '.trae';
+    this.rulesDir = 'rules';
+  }
+
+  /**
+   * Setup Trae 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 .trae/rules directory
+    const traeDir = path.join(projectDir, this.configDir);
+    const rulesDir = path.join(traeDir, this.rulesDir);
+
+    await this.ensureDir(rulesDir);
+
+    // Clean up any existing BMAD files before reinstalling
+    await this.cleanup(projectDir);
+
+    // Get agents, tasks, tools, and workflows (standalone only)
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir, true);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Process agents as rules with bmad- prefix
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readFile(agent.path);
+      const processedContent = this.createAgentRule(agent, content, bmadDir, projectDir);
+
+      // Use bmad- prefix: bmad-agent-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-agent-${agent.module}-${agent.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      agentCount++;
+    }
+
+    // Process tasks as rules with bmad- prefix
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const processedContent = this.createTaskRule(task, content);
+
+      // Use bmad- prefix: bmad-task-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-task-${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      taskCount++;
+    }
+
+    // Process tools as rules with bmad- prefix
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readFile(tool.path);
+      const processedContent = this.createToolRule(tool, content);
+
+      // Use bmad- prefix: bmad-tool-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-tool-${tool.module}-${tool.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      toolCount++;
+    }
+
+    // Process workflows as rules with bmad- prefix
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readFile(workflow.path);
+      const processedContent = this.createWorkflowRule(workflow, content);
+
+      // Use bmad- prefix: bmad-workflow-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-workflow-${workflow.module}-${workflow.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      workflowCount++;
+    }
+
+    const totalRules = agentCount + taskCount + toolCount + workflowCount;
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agent rules created`));
+    console.log(chalk.dim(`  - ${taskCount} task rules created`));
+    console.log(chalk.dim(`  - ${toolCount} tool rules created`));
+    console.log(chalk.dim(`  - ${workflowCount} workflow rules created`));
+    console.log(chalk.dim(`  - Total: ${totalRules} rules`));
+    console.log(chalk.dim(`  - Rules directory: ${path.relative(projectDir, rulesDir)}`));
+    console.log(chalk.dim(`  - Agents can be activated with @{agent-name}`));
+
+    return {
+      success: true,
+      rules: totalRules,
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Create rule content for an agent
+   */
+  createAgentRule(agent, content, bmadDir, projectDir) {
+    // Extract metadata from agent content
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    const iconMatch = content.match(/icon="([^"]+)"/);
+    const icon = iconMatch ? iconMatch[1] : '🤖';
+
+    // Extract YAML content if available
+    const yamlMatch = content.match(/```ya?ml\r?\n([\s\S]*?)```/);
+    const yamlContent = yamlMatch ? yamlMatch[1] : content;
+
+    // Calculate relative path for reference
+    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
+
+    let ruleContent = `# ${title} Agent Rule
+
+This rule is triggered when the user types \`@${agent.name}\` and activates the ${title} agent persona.
+
+## Agent Activation
+
+CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
+
+\`\`\`yaml
+${yamlContent}
+\`\`\`
+
+## File Reference
+
+The complete agent definition is available in [${relativePath}](${relativePath}).
+
+## Usage
+
+When the user types \`@${agent.name}\`, activate this ${title} persona and follow all instructions defined in the YAML configuration above.
+
+## Module
+
+Part of the BMAD ${agent.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Create rule content for a task
+   */
+  createTaskRule(task, content) {
+    // Extract task name from content
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    let ruleContent = `# ${taskName} Task Rule
+
+This rule defines the ${taskName} task workflow.
+
+## Task Definition
+
+When this task is triggered, execute the following workflow:
+
+${content}
+
+## Usage
+
+Reference this task with \`@task-${task.name}\` to execute the defined workflow.
+
+## Module
+
+Part of the BMAD ${task.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Create rule content for a tool
+   */
+  createToolRule(tool, content) {
+    // Extract tool name from content
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const toolName = nameMatch ? nameMatch[1] : this.formatTitle(tool.name);
+
+    let ruleContent = `# ${toolName} Tool Rule
+
+This rule defines the ${toolName} tool.
+
+## Tool Definition
+
+When this tool is triggered, execute the following:
+
+${content}
+
+## Usage
+
+Reference this tool with \`@tool-${tool.name}\` to execute it.
+
+## Module
+
+Part of the BMAD ${tool.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Create rule content for a workflow
+   */
+  createWorkflowRule(workflow, content) {
+    let ruleContent = `# ${workflow.name} Workflow Rule
+
+This rule defines the ${workflow.name} workflow.
+
+## Workflow Description
+
+${workflow.description || 'No description provided'}
+
+## Workflow Definition
+
+${content}
+
+## Usage
+
+Reference this workflow with \`@workflow-${workflow.name}\` to execute the guided workflow.
+
+## Module
+
+Part of the BMAD ${workflow.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Format agent/task name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Trae configuration - surgically remove only BMAD files
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const rulesPath = path.join(projectDir, this.configDir, this.rulesDir);
+
+    if (await fs.pathExists(rulesPath)) {
+      // Only remove files that start with bmad- prefix
+      const files = await fs.readdir(rulesPath);
+      let removed = 0;
+
+      for (const file of files) {
+        if (file.startsWith('bmad-') && file.endsWith('.md')) {
+          await fs.remove(path.join(rulesPath, file));
+          removed++;
+        }
+      }
+
+      if (removed > 0) {
+        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD rules`));
+      }
+    }
+  }
+}
+
+module.exports = { TraeSetup };

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

@@ -0,0 +1,201 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Windsurf IDE setup handler
+ */
+class WindsurfSetup extends BaseIdeSetup {
+  constructor() {
+    super('windsurf', 'Windsurf', true); // preferred IDE
+    this.configDir = '.windsurf';
+    this.workflowsDir = 'workflows';
+  }
+
+  /**
+   * Setup Windsurf 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 .windsurf/workflows/bmad directory structure
+    const windsurfDir = path.join(projectDir, this.configDir);
+    const workflowsDir = path.join(windsurfDir, this.workflowsDir);
+    const bmadWorkflowsDir = path.join(workflowsDir, 'bmad');
+
+    await this.ensureDir(bmadWorkflowsDir);
+
+    // Clean up any existing BMAD workflows before reinstalling
+    await this.cleanup(projectDir);
+
+    // Get agents, tasks, tools, and workflows (standalone only)
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir, true);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Create directories for each module under bmad/
+    const modules = new Set();
+    for (const item of [...agents, ...tasks, ...tools, ...workflows]) modules.add(item.module);
+
+    for (const module of modules) {
+      await this.ensureDir(path.join(bmadWorkflowsDir, module));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'agents'));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'tasks'));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'tools'));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'workflows'));
+    }
+
+    // Process agents as workflows with organized structure
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readFile(agent.path);
+      const processedContent = this.createWorkflowContent(agent, content);
+
+      // Organized path: bmad/module/agents/agent-name.md
+      const targetPath = path.join(bmadWorkflowsDir, agent.module, 'agents', `${agent.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      agentCount++;
+    }
+
+    // Process tasks as workflows with organized structure
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const processedContent = this.createTaskWorkflowContent(task, content);
+
+      // Organized path: bmad/module/tasks/task-name.md
+      const targetPath = path.join(bmadWorkflowsDir, task.module, 'tasks', `${task.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      taskCount++;
+    }
+
+    // Process tools as workflows with organized structure
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readFile(tool.path);
+      const processedContent = this.createToolWorkflowContent(tool, content);
+
+      // Organized path: bmad/module/tools/tool-name.md
+      const targetPath = path.join(bmadWorkflowsDir, tool.module, 'tools', `${tool.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      toolCount++;
+    }
+
+    // Process workflows with organized structure
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readFile(workflow.path);
+      const processedContent = this.createWorkflowWorkflowContent(workflow, content);
+
+      // Organized path: bmad/module/workflows/workflow-name.md
+      const targetPath = path.join(bmadWorkflowsDir, workflow.module, 'workflows', `${workflow.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      workflowCount++;
+    }
+
+    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(`  - ${toolCount} tools installed`));
+    console.log(chalk.dim(`  - ${workflowCount} workflows installed`));
+    console.log(chalk.dim(`  - Organized in modules: ${[...modules].join(', ')}`));
+    console.log(chalk.dim(`  - Workflows directory: ${path.relative(projectDir, workflowsDir)}`));
+
+    // Provide additional configuration hints
+    if (options.showHints !== false) {
+      console.log(chalk.dim('\n  Windsurf workflow settings:'));
+      console.log(chalk.dim('  - auto_execution_mode: 3 (recommended for agents)'));
+      console.log(chalk.dim('  - auto_execution_mode: 2 (recommended for tasks/tools)'));
+      console.log(chalk.dim('  - auto_execution_mode: 1 (recommended for workflows)'));
+      console.log(chalk.dim('  - Workflows can be triggered via the Windsurf menu'));
+    }
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Create workflow content for an agent
+   */
+  createWorkflowContent(agent, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: ${agent.name}
+auto_execution_mode: 3
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Create workflow content for a task
+   */
+  createTaskWorkflowContent(task, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: task-${task.name}
+auto_execution_mode: 2
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Create workflow content for a tool
+   */
+  createToolWorkflowContent(tool, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: tool-${tool.name}
+auto_execution_mode: 2
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Create workflow content for a workflow
+   */
+  createWorkflowWorkflowContent(workflow, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: ${workflow.name}
+auto_execution_mode: 1
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Cleanup Windsurf configuration - surgically remove only BMAD files
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const bmadPath = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad');
+
+    if (await fs.pathExists(bmadPath)) {
+      // Remove the entire bmad folder - this is our territory
+      await fs.remove(bmadPath);
+      console.log(chalk.dim(`  Cleaned up existing BMAD workflows`));
+    }
+  }
+}
+
+module.exports = { WindsurfSetup };

package/tools/cli/installers/lib/ide/workflow-command-generator.js

@@ -0,0 +1,235 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const chalk = require('chalk');
+
+/**
+ * Generates Claude Code command files for each workflow in the manifest
+ */
+class WorkflowCommandGenerator {
+  constructor() {
+    this.templatePath = path.join(__dirname, 'workflow-command-template.md');
+  }
+
+  /**
+   * Generate workflow commands from the manifest CSV
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   */
+  async generateWorkflowCommands(projectDir, bmadDir) {
+    const workflows = await this.loadWorkflowManifest(bmadDir);
+
+    if (!workflows) {
+      console.log(chalk.yellow('Workflow manifest not found. Skipping command generation.'));
+      return { generated: 0 };
+    }
+
+    // Filter to only standalone workflows
+    const standaloneWorkflows = workflows.filter((w) => w.standalone === 'true' || w.standalone === true);
+
+    // Base commands directory
+    const baseCommandsDir = path.join(projectDir, '.claude', 'commands', 'bmad');
+
+    let generatedCount = 0;
+
+    // Generate a command file for each standalone workflow, organized by module
+    for (const workflow of standaloneWorkflows) {
+      const moduleWorkflowsDir = path.join(baseCommandsDir, workflow.module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+
+      const commandContent = await this.generateCommandContent(workflow, bmadDir);
+      const commandPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Also create a workflow launcher README in each module
+    const groupedWorkflows = this.groupWorkflowsByModule(standaloneWorkflows);
+    await this.createModuleWorkflowLaunchers(baseCommandsDir, groupedWorkflows);
+
+    return { generated: generatedCount };
+  }
+
+  async collectWorkflowArtifacts(bmadDir) {
+    const workflows = await this.loadWorkflowManifest(bmadDir);
+
+    if (!workflows) {
+      return { artifacts: [], counts: { commands: 0, launchers: 0 } };
+    }
+
+    // Filter to only standalone workflows
+    const standaloneWorkflows = workflows.filter((w) => w.standalone === 'true' || w.standalone === true);
+
+    const artifacts = [];
+
+    for (const workflow of standaloneWorkflows) {
+      const commandContent = await this.generateCommandContent(workflow, bmadDir);
+      artifacts.push({
+        type: 'workflow-command',
+        module: workflow.module,
+        relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
+        content: commandContent,
+        sourcePath: workflow.path,
+      });
+    }
+
+    const groupedWorkflows = this.groupWorkflowsByModule(standaloneWorkflows);
+    for (const [module, launcherContent] of Object.entries(this.buildModuleWorkflowLaunchers(groupedWorkflows))) {
+      artifacts.push({
+        type: 'workflow-launcher',
+        module,
+        relativePath: path.join(module, 'workflows', 'README.md'),
+        content: launcherContent,
+        sourcePath: null,
+      });
+    }
+
+    return {
+      artifacts,
+      counts: {
+        commands: standaloneWorkflows.length,
+        launchers: Object.keys(groupedWorkflows).length,
+      },
+    };
+  }
+
+  /**
+   * Generate command content for a workflow
+   */
+  async generateCommandContent(workflow, bmadDir) {
+    // Load the template
+    const template = await fs.readFile(this.templatePath, 'utf8');
+
+    // Convert source path to installed path
+    // From: /Users/.../src/modules/bmm/workflows/.../workflow.yaml
+    // To: {project-root}/bmad/bmm/workflows/.../workflow.yaml
+    let workflowPath = workflow.path;
+
+    // Extract the relative path from source
+    if (workflowPath.includes('/src/modules/')) {
+      const match = workflowPath.match(/\/src\/modules\/(.+)/);
+      if (match) {
+        workflowPath = `{project-root}/bmad/${match[1]}`;
+      }
+    } else if (workflowPath.includes('/src/core/')) {
+      const match = workflowPath.match(/\/src\/core\/(.+)/);
+      if (match) {
+        workflowPath = `{project-root}/bmad/core/${match[1]}`;
+      }
+    }
+
+    // Replace template variables
+    return template
+      .replaceAll('{{name}}', workflow.name)
+      .replaceAll('{{module}}', workflow.module)
+      .replaceAll('{{description}}', workflow.description)
+      .replaceAll('{{workflow_path}}', workflowPath)
+      .replaceAll('{{interactive}}', workflow.interactive)
+      .replaceAll('{{author}}', workflow.author || 'BMAD');
+  }
+
+  /**
+   * Create workflow launcher files for each module
+   */
+  async createModuleWorkflowLaunchers(baseCommandsDir, workflowsByModule) {
+    for (const [module, moduleWorkflows] of Object.entries(workflowsByModule)) {
+      const content = this.buildLauncherContent(module, moduleWorkflows);
+      const moduleWorkflowsDir = path.join(baseCommandsDir, module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+      const launcherPath = path.join(moduleWorkflowsDir, 'README.md');
+      await fs.writeFile(launcherPath, content);
+    }
+  }
+
+  groupWorkflowsByModule(workflows) {
+    const workflowsByModule = {};
+
+    for (const workflow of workflows) {
+      if (!workflowsByModule[workflow.module]) {
+        workflowsByModule[workflow.module] = [];
+      }
+
+      workflowsByModule[workflow.module].push({
+        ...workflow,
+        displayPath: this.transformWorkflowPath(workflow.path),
+      });
+    }
+
+    return workflowsByModule;
+  }
+
+  buildModuleWorkflowLaunchers(groupedWorkflows) {
+    const launchers = {};
+
+    for (const [module, moduleWorkflows] of Object.entries(groupedWorkflows)) {
+      launchers[module] = this.buildLauncherContent(module, moduleWorkflows);
+    }
+
+    return launchers;
+  }
+
+  buildLauncherContent(module, moduleWorkflows) {
+    let content = `# ${module.toUpperCase()} Workflows
+
+## Available Workflows in ${module}
+
+`;
+
+    for (const workflow of moduleWorkflows) {
+      content += `**${workflow.name}**\n`;
+      content += `- Path: \`${workflow.displayPath}\`\n`;
+      content += `- ${workflow.description}\n\n`;
+    }
+
+    content += `
+## Execution
+
+When running any workflow:
+1. LOAD {project-root}/bmad/core/tasks/workflow.xml
+2. Pass the workflow path as 'workflow-config' parameter
+3. Follow workflow.xml instructions EXACTLY
+4. Save outputs after EACH section
+
+## Modes
+- Normal: Full interaction
+- #yolo: Skip optional steps
+`;
+
+    return content;
+  }
+
+  transformWorkflowPath(workflowPath) {
+    let transformed = workflowPath;
+
+    if (workflowPath.includes('/src/modules/')) {
+      const match = workflowPath.match(/\/src\/modules\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/bmad/${match[1]}`;
+      }
+    } else if (workflowPath.includes('/src/core/')) {
+      const match = workflowPath.match(/\/src\/core\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/bmad/core/${match[1]}`;
+      }
+    }
+
+    return transformed;
+  }
+
+  async loadWorkflowManifest(bmadDir) {
+    const manifestPath = path.join(bmadDir, '_cfg', 'workflow-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+  }
+}
+
+module.exports = { WorkflowCommandGenerator };