bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.10

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

@@ -1,6 +1,7 @@
 const path = require('node:path');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
 
 /**
  * Cursor IDE setup handler
@@ -12,6 +13,20 @@ class CursorSetup extends BaseIdeSetup {
     this.rulesDir = 'rules';
   }
 
+  /**
+   * Cleanup old BMAD installation before reinstalling
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const bmadRulesDir = path.join(projectDir, this.configDir, this.rulesDir, 'bmad');
+
+    if (await fs.pathExists(bmadRulesDir)) {
+      await fs.remove(bmadRulesDir);
+      console.log(chalk.dim(`  Removed old BMAD rules from ${this.name}`));
+    }
+  }
+
   /**
    * Setup Cursor IDE configuration
    * @param {string} projectDir - Project directory
@@ -21,6 +36,9 @@ class CursorSetup extends BaseIdeSetup {
   async setup(projectDir, bmadDir, options = {}) {
     console.log(chalk.cyan(`Setting up ${this.name}...`));
 
+    // Clean up old BMAD installation first
+    await this.cleanup(projectDir);
+
     // Create .cursor/rules directory structure
     const cursorDir = path.join(projectDir, this.configDir);
     const rulesDir = path.join(cursorDir, this.rulesDir);
@@ -28,29 +46,40 @@ class CursorSetup extends BaseIdeSetup {
 
     await this.ensureDir(bmadRulesDir);
 
-    // Get agents and tasks
-    const agents = await this.getAgents(bmadDir);
-    const tasks = await this.getTasks(bmadDir);
+    // Generate agent launchers first
+    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
+
+    // Convert artifacts to agent format for index creation
+    const agents = agentArtifacts.map((a) => ({ module: a.module, name: a.name }));
+
+    // Get tasks, tools, and workflows (standalone only)
+    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
     const modules = new Set();
-    for (const item of [...agents, ...tasks]) modules.add(item.module);
+    for (const item of [...agents, ...tasks, ...tools, ...workflows]) 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'));
+      await this.ensureDir(path.join(bmadRulesDir, module, 'tools'));
+      await this.ensureDir(path.join(bmadRulesDir, module, 'workflows'));
     }
 
-    // Process and copy agents
+    // Process and write agent launchers with MDC format
     let agentCount = 0;
-    for (const agent of agents) {
-      const content = await this.readAndProcess(agent.path, {
-        module: agent.module,
-        name: agent.name,
+    for (const artifact of agentArtifacts) {
+      // Add MDC metadata header to launcher (but don't call processContent which adds activation headers)
+      const content = this.wrapLauncherWithMDC(artifact.content, {
+        module: artifact.module,
+        name: artifact.name,
       });
 
-      const targetPath = path.join(bmadRulesDir, agent.module, 'agents', `${agent.name}.mdc`);
+      const targetPath = path.join(bmadRulesDir, artifact.module, 'agents', `${artifact.name}.mdc`);
 
       await this.writeFile(targetPath, content);
       agentCount++;
@@ -70,36 +99,68 @@ class CursorSetup extends BaseIdeSetup {
       taskCount++;
     }
 
+    // Process and copy tools
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readAndProcess(tool.path, {
+        module: tool.module,
+        name: tool.name,
+      });
+
+      const targetPath = path.join(bmadRulesDir, tool.module, 'tools', `${tool.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      toolCount++;
+    }
+
+    // Process and copy workflows
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readAndProcess(workflow.path, {
+        module: workflow.module,
+        name: workflow.name,
+      });
+
+      const targetPath = path.join(bmadRulesDir, workflow.module, 'workflows', `${workflow.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      workflowCount++;
+    }
+
     // Create BMAD index file (but NOT .cursorrules - user manages that)
-    await this.createBMADIndex(bmadRulesDir, agents, tasks, modules);
+    await this.createBMADIndex(bmadRulesDir, agents, tasks, tools, workflows, 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(`  - ${toolCount} tools installed`));
+    console.log(chalk.dim(`  - ${workflowCount} workflows installed`));
     console.log(chalk.dim(`  - Rules directory: ${path.relative(projectDir, bmadRulesDir)}`));
 
     return {
       success: true,
       agents: agentCount,
       tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
     };
   }
 
   /**
    * Create BMAD index file for easy navigation
    */
-  async createBMADIndex(bmadRulesDir, agents, tasks, modules) {
+  async createBMADIndex(bmadRulesDir, agents, tasks, tools, workflows, modules) {
     const indexPath = path.join(bmadRulesDir, 'index.mdc');
 
     let content = `---
 description: BMAD Method - Master Index
-globs: 
+globs:
 alwaysApply: true
 ---
 
 # BMAD Method - Cursor Rules Index
 
-This is the master index for all BMAD agents and tasks available in your project.
+This is the master index for all BMAD agents, tasks, tools, and workflows available in your project.
 
 ## Installation Complete!
 
@@ -111,6 +172,8 @@ BMAD rules have been installed to: \`.cursor/rules/bmad/\`
 
 - Reference specific agents: @bmad/{module}/agents/{agent-name}
 - Reference specific tasks: @bmad/{module}/tasks/{task-name}
+- Reference specific tools: @bmad/{module}/tools/{tool-name}
+- Reference specific workflows: @bmad/{module}/workflows/{workflow-name}
 - Reference entire modules: @bmad/{module}
 - Reference this index: @bmad/index
 
@@ -140,6 +203,26 @@ BMAD rules have been installed to: \`.cursor/rules/bmad/\`
         }
         content += '\n';
       }
+
+      // List tools for this module
+      const moduleTools = tools.filter((t) => t.module === module);
+      if (moduleTools.length > 0) {
+        content += `**Tools:**\n`;
+        for (const tool of moduleTools) {
+          content += `- @bmad/${module}/tools/${tool.name} - ${tool.name}\n`;
+        }
+        content += '\n';
+      }
+
+      // List workflows for this module
+      const moduleWorkflows = workflows.filter((w) => w.module === module);
+      if (moduleWorkflows.length > 0) {
+        content += `**Workflows:**\n`;
+        for (const workflow of moduleWorkflows) {
+          content += `- @bmad/${module}/workflows/${workflow.name} - ${workflow.name}\n`;
+        }
+        content += '\n';
+      }
     }
 
     content += `
@@ -148,13 +231,15 @@ BMAD rules have been installed to: \`.cursor/rules/bmad/\`
 - 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
+- Tools provide specialized functionality
+- Workflows orchestrate multi-step processes
 - 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.
+specific agent expertise, task workflows, tools, or guided workflows.
 `;
 
     await this.writeFile(indexPath, content);
@@ -179,9 +264,18 @@ specific agent expertise or task workflows.
     // First apply base processing (includes activation injection for agents)
     let processed = super.processContent(content, metadata);
 
+    // Strip any existing frontmatter from the processed content
+    // This prevents duplicate frontmatter blocks
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    if (frontmatterRegex.test(processed)) {
+      processed = processed.replace(frontmatterRegex, '');
+    }
+
     // Determine the type and description based on content
     const isAgent = content.includes('<agent');
     const isTask = content.includes('<task');
+    const isTool = content.includes('<tool');
+    const isWorkflow = content.includes('workflow:') || content.includes('name:');
 
     let description = '';
     let globs = '';
@@ -191,16 +285,22 @@ specific agent expertise or task workflows.
       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 nameMatch = content.match(/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 if (isTool) {
+      // Extract tool name if available
+      const nameMatch = content.match(/name="([^"]+)"/);
+      const toolName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Tool: ${toolName}`;
+      globs = '';
+    } else if (isWorkflow) {
+      // Workflow
+      description = `BMAD ${metadata.module.toUpperCase()} Workflow: ${metadata.name}`;
       globs = '';
     } else {
       description = `BMAD ${metadata.module.toUpperCase()}: ${metadata.name}`;
@@ -219,6 +319,34 @@ alwaysApply: false
     // Add the MDC header to the processed content
     return mdcHeader + processed;
   }
+
+  /**
+   * Wrap launcher content with MDC metadata (without base processing)
+   * Launchers are already complete and should not have activation headers injected
+   */
+  wrapLauncherWithMDC(launcherContent, metadata = {}) {
+    // Strip the launcher's frontmatter - we'll replace it with MDC frontmatter
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = launcherContent.replace(frontmatterRegex, '');
+
+    // Extract metadata from launcher frontmatter for MDC description
+    const nameMatch = launcherContent.match(/name:\s*"([^"]+)"/);
+    const name = nameMatch ? nameMatch[1] : metadata.name;
+
+    const description = `BMAD ${metadata.module.toUpperCase()} Agent: ${name}`;
+
+    // Create MDC metadata header
+    const mdcHeader = `---
+description: ${description}
+globs:
+alwaysApply: false
+---
+
+`;
+
+    // Return MDC header + launcher content (without its original frontmatter)
+    return mdcHeader + contentWithoutFrontmatter;
+  }
 }
 
 module.exports = { CursorSetup };

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

@@ -1,6 +1,9 @@
 const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
 
 /**
  * Gemini CLI setup handler
@@ -8,9 +11,39 @@ const chalk = require('chalk');
  */
 class GeminiSetup extends BaseIdeSetup {
   constructor() {
-    super('gemini', 'Gemini CLI', true); // preferred IDE
+    super('gemini', 'Gemini CLI', false);
     this.configDir = '.gemini';
     this.commandsDir = 'commands';
+    this.agentTemplatePath = path.join(__dirname, 'templates', 'gemini-agent-command.toml');
+    this.taskTemplatePath = path.join(__dirname, 'templates', 'gemini-task-command.toml');
+  }
+
+  /**
+   * Load config values from bmad installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {Object} Config values
+   */
+  async loadConfigValues(bmadDir) {
+    const configValues = {
+      user_name: 'User', // Default fallback
+    };
+
+    // Try to load core config.yaml
+    const coreConfigPath = path.join(bmadDir, 'core', 'config.yaml');
+    if (await fs.pathExists(coreConfigPath)) {
+      try {
+        const configContent = await fs.readFile(coreConfigPath, 'utf8');
+        const config = yaml.load(configContent);
+
+        if (config.user_name) {
+          configValues.user_name = config.user_name;
+        }
+      } catch (error) {
+        console.warn(chalk.yellow(`  Warning: Could not load config values: ${error.message}`));
+      }
+    }
+
+    return configValues;
   }
 
   /**
@@ -22,43 +55,47 @@ class GeminiSetup extends BaseIdeSetup {
   async setup(projectDir, bmadDir, options = {}) {
     console.log(chalk.cyan(`Setting up ${this.name}...`));
 
-    // Create .gemini/commands/agents and .gemini/commands/tasks directories
+    // Create .gemini/commands directory (flat structure with bmad- prefix)
     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);
+    await this.ensureDir(commandsDir);
+
+    // Clean up any existing BMAD files before reinstalling
+    await this.cleanup(projectDir);
 
-    // Get agents and tasks
-    const agents = await this.getAgents(bmadDir);
+    // Generate agent launchers
+    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
+
+    // Get tasks
     const tasks = await this.getTasks(bmadDir);
 
-    // Install agents as TOML files
+    // Install agents as TOML files with bmad- prefix (flat structure)
     let agentCount = 0;
-    for (const agent of agents) {
-      const content = await this.readFile(agent.path);
-      const tomlContent = this.createAgentToml(agent, content, bmadDir);
+    for (const artifact of agentArtifacts) {
+      const tomlContent = await this.createAgentLauncherToml(artifact);
 
-      const tomlPath = path.join(agentsDir, `${agent.name}.toml`);
+      // Flat structure: bmad-agent-{module}-{name}.toml
+      const tomlPath = path.join(commandsDir, `bmad-agent-${artifact.module}-${artifact.name}.toml`);
       await this.writeFile(tomlPath, tomlContent);
       agentCount++;
 
-      console.log(chalk.green(`  ✓ Added agent: /bmad:agents:${agent.name}`));
+      console.log(chalk.green(`  ✓ Added agent: /bmad:agents:${artifact.module}:${artifact.name}`));
     }
 
-    // Install tasks as TOML files
+    // Install tasks as TOML files with bmad- prefix (flat structure)
     let taskCount = 0;
     for (const task of tasks) {
       const content = await this.readFile(task.path);
-      const tomlContent = this.createTaskToml(task, content, bmadDir);
+      const tomlContent = await this.createTaskToml(task, content);
 
-      const tomlPath = path.join(tasksDir, `${task.name}.toml`);
+      // Flat structure: bmad-task-{module}-{name}.toml
+      const tomlPath = path.join(commandsDir, `bmad-task-${task.module}-${task.name}.toml`);
       await this.writeFile(tomlPath, tomlContent);
       taskCount++;
 
-      console.log(chalk.green(`  ✓ Added task: /bmad:tasks:${task.name}`));
+      console.log(chalk.green(`  ✓ Added task: /bmad:tasks:${task.module}:${task.name}`));
     }
 
     console.log(chalk.green(`✓ ${this.name} configured:`));
@@ -76,84 +113,93 @@ class GeminiSetup extends BaseIdeSetup {
   }
 
   /**
-   * Create agent TOML content
+   * Create agent launcher TOML content from artifact
    */
-  createAgentToml(agent, content, bmadDir) {
-    // Extract metadata
-    const titleMatch = content.match(/title="([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+  async createAgentLauncherToml(artifact) {
+    // Strip frontmatter from launcher content
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
 
-    // Get relative path from project root to agent file
-    const relativePath = path.relative(process.cwd(), agent.path).replaceAll('\\', '/');
+    // Extract title from launcher frontmatter
+    const titleMatch = artifact.content.match(/description:\s*"([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
 
-    // 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.
+    // Create TOML wrapper around launcher content (without frontmatter)
+    const description = `BMAD ${artifact.module.toUpperCase()} Agent: ${title}`;
 
-Read and internalize the full agent definition, following all instructions and maintaining this persona until explicitly told to switch or exit.
-
-@${relativePath}
+    return `description = "${description}"
+prompt = """
+${contentWithoutFrontmatter}
 """
 `;
+  }
+
+  /**
+   * Create agent TOML content using template
+   */
+  async createAgentToml(agent, content) {
+    // Extract metadata
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    // Load template
+    const template = await fs.readFile(this.agentTemplatePath, 'utf8');
+
+    // Replace template variables
+    // Note: {user_name} and other {config_values} are left as-is for runtime substitution by Gemini
+    const tomlContent = template
+      .replaceAll('{{title}}', title)
+      .replaceAll('{{bmad_folder}}', this.bmadFolderName)
+      .replaceAll('{{module}}', agent.module)
+      .replaceAll('{{name}}', agent.name);
 
     return tomlContent;
   }
 
   /**
-   * Create task TOML content
+   * Create task TOML content using template
    */
-  createTaskToml(task, content, bmadDir) {
+  async createTaskToml(task, content) {
     // 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('\\', '/');
+    // Load template
+    const template = await fs.readFile(this.taskTemplatePath, 'utf8');
 
-    // 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.
-"""
-`;
+    // Replace template variables
+    const tomlContent = template
+      .replaceAll('{{taskName}}', taskName)
+      .replaceAll('{{bmad_folder}}', this.bmadFolderName)
+      .replaceAll('{{module}}', task.module)
+      .replaceAll('{{filename}}', task.filename);
 
     return tomlContent;
   }
 
   /**
-   * Cleanup Gemini configuration
+   * Cleanup Gemini configuration - surgically remove only BMAD files
    */
   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);
+    if (await fs.pathExists(commandsDir)) {
+      // Only remove files that start with bmad- prefix
+      const files = await fs.readdir(commandsDir);
+      let removed = 0;
+
       for (const file of files) {
-        if (file.endsWith('.toml')) {
-          await fs.remove(path.join(agentsDir, file));
+        if (file.startsWith('bmad-') && file.endsWith('.toml')) {
+          await fs.remove(path.join(commandsDir, file));
+          removed++;
         }
       }
-    }
 
-    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));
-        }
+      if (removed > 0) {
+        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD files`));
       }
     }
-
-    console.log(chalk.dim(`Removed BMAD configuration from Gemini CLI`));
   }
 }