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

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

@@ -28,18 +28,22 @@ class CursorSetup extends BaseIdeSetup {
 
     await this.ensureDir(bmadRulesDir);
 
-    // Get agents and tasks
+    // Get agents, tasks, tools, and workflows (standalone only)
     const agents = await this.getAgents(bmadDir);
-    const tasks = await this.getTasks(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
     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
@@ -70,36 +74,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 +147,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 +178,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 +206,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);
@@ -182,6 +242,8 @@ specific agent expertise or task workflows.
     // 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 +253,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}`;

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

@@ -22,43 +22,45 @@ 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);
     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);
 
-      const tomlPath = path.join(agentsDir, `${agent.name}.toml`);
+      // Flat structure: bmad-agent-{module}-{name}.toml
+      const tomlPath = path.join(commandsDir, `bmad-agent-${agent.module}-${agent.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:${agent.module}:${agent.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 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:`));
@@ -126,34 +128,28 @@ Follow all instructions and complete the task as defined.
   }
 
   /**
-   * 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`));
   }
 }
 

package/tools/cli/installers/lib/ide/github-copilot.js

@@ -101,20 +101,24 @@ class GitHubCopilotSetup extends BaseIdeSetup {
     const chatmodesDir = path.join(githubDir, this.chatmodesDir);
     await this.ensureDir(chatmodesDir);
 
+    // Clean up any existing BMAD files before reinstalling
+    await this.cleanup(projectDir);
+
     // Get agents
     const agents = await this.getAgents(bmadDir);
 
-    // Create chat mode files
+    // Create chat mode files with bmad- prefix
     let modeCount = 0;
     for (const agent of agents) {
       const content = await this.readFile(agent.path);
       const chatmodeContent = this.createChatmodeContent(agent, content);
 
-      const targetPath = path.join(chatmodesDir, `${agent.module}-${agent.name}.chatmode.md`);
+      // Use bmad- prefix: bmad-agent-{module}-{name}.chatmode.md
+      const targetPath = path.join(chatmodesDir, `bmad-agent-${agent.module}-${agent.name}.chatmode.md`);
       await this.writeFile(targetPath, chatmodeContent);
       modeCount++;
 
-      console.log(chalk.green(`  ✓ Created chat mode: ${agent.module}-${agent.name}`));
+      console.log(chalk.green(`  ✓ Created chat mode: bmad-agent-${agent.module}-${agent.name}`));
     }
 
     console.log(chalk.green(`✓ ${this.name} configured:`));
@@ -258,30 +262,27 @@ Part of the BMAD ${agent.module.toUpperCase()} module.
   }
 
   /**
-   * Cleanup GitHub Copilot configuration
+   * Cleanup GitHub Copilot configuration - surgically remove only BMAD files
    */
   async cleanup(projectDir) {
     const fs = require('fs-extra');
     const chatmodesDir = path.join(projectDir, this.configDir, this.chatmodesDir);
 
     if (await fs.pathExists(chatmodesDir)) {
-      // Remove BMAD chat modes
+      // Only remove files that start with bmad- prefix
       const files = await fs.readdir(chatmodesDir);
       let removed = 0;
 
       for (const file of files) {
-        if (file.endsWith('.chatmode.md')) {
-          const filePath = path.join(chatmodesDir, file);
-          const content = await fs.readFile(filePath, 'utf8');
-
-          if (content.includes('BMAD') && content.includes('Module')) {
-            await fs.remove(filePath);
-            removed++;
-          }
+        if (file.startsWith('bmad-') && file.endsWith('.chatmode.md')) {
+          await fs.remove(path.join(chatmodesDir, file));
+          removed++;
         }
       }
 
-      console.log(chalk.dim(`Removed ${removed} BMAD chat modes from GitHub Copilot`));
+      if (removed > 0) {
+        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD chat modes`));
+      }
     }
   }
 }

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

@@ -22,7 +22,13 @@ class IdeManager {
       // Get all JS files in the IDE directory
       const files = fs.readdirSync(ideDir).filter((file) => {
         // Skip base class, manager, utility files (starting with _), and helper modules
-        return file.endsWith('.js') && !file.startsWith('_') && file !== 'manager.js' && file !== 'workflow-command-generator.js';
+        return (
+          file.endsWith('.js') &&
+          !file.startsWith('_') &&
+          file !== 'manager.js' &&
+          file !== 'workflow-command-generator.js' &&
+          file !== 'task-tool-command-generator.js'
+        );
       });
 
       // Sort alphabetically for consistent ordering
@@ -41,7 +47,12 @@ class IdeManager {
           if (HandlerClass) {
             const instance = new HandlerClass();
             // Use the name property from the instance (set in constructor)
-            this.handlers.set(instance.name, instance);
+            // Only add if the instance has a valid name
+            if (instance.name && typeof instance.name === 'string') {
+              this.handlers.set(instance.name, instance);
+            } else {
+              console.log(chalk.yellow(`  Warning: ${moduleName} handler missing valid 'name' property`));
+            }
           }
         } catch (error) {
           console.log(chalk.yellow(`  Warning: Could not load ${moduleName}: ${error.message}`));
@@ -60,9 +71,17 @@ class IdeManager {
     const ides = [];
 
     for (const [key, handler] of this.handlers) {
+      // Skip handlers without valid names
+      const name = handler.displayName || handler.name || key;
+
+      // Filter out invalid entries (undefined name, empty key, etc.)
+      if (!key || !name || typeof key !== 'string' || typeof name !== 'string') {
+        continue;
+      }
+
       ides.push({
         value: key,
-        name: handler.displayName || handler.name || key,
+        name: name,
         preferred: handler.preferred || false,
       });
     }
@@ -71,10 +90,7 @@ class IdeManager {
     ides.sort((a, b) => {
       if (a.preferred && !b.preferred) return -1;
       if (!a.preferred && b.preferred) return 1;
-      // Ensure both names exist before comparing
-      const nameA = a.name || '';
-      const nameB = b.name || '';
-      return nameA.localeCompare(nameB);
+      return a.name.localeCompare(b.name);
     });
 
     return ides;
@@ -165,37 +181,12 @@ class IdeManager {
   async detectInstalledIdes(projectDir) {
     const detected = [];
 
-    // Check for IDE-specific directories
-    const ideChecks = {
-      cursor: '.cursor',
-      'claude-code': '.claude',
-      windsurf: '.windsurf',
-      cline: '.clinerules',
-      roo: '.roomodes',
-      trae: '.trae',
-      kilo: '.kilocodemodes',
-      gemini: '.gemini',
-      qwen: '.qwen',
-      crush: '.crush',
-      iflow: '.iflow',
-      auggie: '.auggie',
-      'github-copilot': '.github/chatmodes',
-      vscode: '.vscode',
-      idea: '.idea',
-    };
-
-    for (const [ide, dir] of Object.entries(ideChecks)) {
-      const idePath = path.join(projectDir, dir);
-      if (await fs.pathExists(idePath)) {
-        detected.push(ide);
+    for (const [name, handler] of this.handlers) {
+      if (typeof handler.detect === 'function' && (await handler.detect(projectDir))) {
+        detected.push(name);
       }
     }
 
-    // Check for AGENTS.md (Codex)
-    if (await fs.pathExists(path.join(projectDir, 'AGENTS.md'))) {
-      detected.push('codex');
-    }
-
     return detected;
   }
 }

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

@@ -0,0 +1,213 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const os = require('node:os');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const { BaseIdeSetup } = require('./_base-ide');
+const { WorkflowCommandGenerator } = require('./workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./task-tool-command-generator');
+
+const { getAgentsFromBmad } = require('./shared/bmad-artifacts');
+
+/**
+ * OpenCode IDE setup handler
+ */
+class OpenCodeSetup extends BaseIdeSetup {
+  constructor() {
+    super('opencode', 'OpenCode', true); // Mark as preferred/recommended
+    this.configDir = '.opencode';
+    this.commandsDir = 'command';
+    this.agentsDir = 'agent';
+  }
+
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    const baseDir = path.join(projectDir, this.configDir);
+    const commandsBaseDir = path.join(baseDir, this.commandsDir);
+    const agentsBaseDir = path.join(baseDir, this.agentsDir);
+
+    await this.ensureDir(commandsBaseDir);
+    await this.ensureDir(agentsBaseDir);
+
+    // Clean up any existing BMAD files before reinstalling
+    await this.cleanup(projectDir);
+
+    // Install primary agents with flat naming: bmad-agent-{module}-{name}.md
+    // OpenCode agents go in the agent folder (not command folder)
+    const agents = await getAgentsFromBmad(bmadDir, options.selectedModules || []);
+
+    let agentCount = 0;
+    for (const agent of agents) {
+      const processed = await this.readAndProcess(agent.path, {
+        module: agent.module,
+        name: agent.name,
+      });
+
+      const agentContent = this.createAgentContent(processed, agent);
+      // Flat structure in agent folder: bmad-agent-{module}-{name}.md
+      const targetPath = path.join(agentsBaseDir, `bmad-agent-${agent.module}-${agent.name}.md`);
+      await this.writeFile(targetPath, agentContent);
+      agentCount++;
+    }
+
+    // Install workflow commands with flat naming: bmad-workflow-{module}-{name}.md
+    const workflowGenerator = new WorkflowCommandGenerator();
+    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
+
+    let workflowCommandCount = 0;
+    for (const artifact of workflowArtifacts) {
+      if (artifact.type === 'workflow-command') {
+        const commandContent = artifact.content;
+        // Flat structure: bmad-workflow-{module}-{name}.md
+        // artifact.relativePath is like: bmm/workflows/plan-project.md
+        const workflowName = path.basename(artifact.relativePath, '.md');
+        const targetPath = path.join(commandsBaseDir, `bmad-workflow-${artifact.module}-${workflowName}.md`);
+        await this.writeFile(targetPath, commandContent);
+        workflowCommandCount++;
+      }
+      // Skip workflow launcher READMEs as they're not needed in flat structure
+    }
+
+    // Install task and tool commands with flat naming
+    const { tasks, tools } = await this.generateFlatTaskToolCommands(bmadDir, commandsBaseDir);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents installed to .opencode/agent/`));
+    if (workflowCommandCount > 0) {
+      console.log(chalk.dim(`  - ${workflowCommandCount} workflows installed to .opencode/command/`));
+    }
+    if (tasks + tools > 0) {
+      console.log(chalk.dim(`  - ${tasks + tools} tasks/tools installed to .opencode/command/ (${tasks} tasks, ${tools} tools)`));
+    }
+
+    return {
+      success: true,
+      agents: agentCount,
+      workflows: workflowCommandCount,
+      workflowCounts,
+    };
+  }
+
+  /**
+   * Generate flat task and tool commands for OpenCode
+   * OpenCode doesn't support nested command directories
+   */
+  async generateFlatTaskToolCommands(bmadDir, commandsBaseDir) {
+    const taskToolGen = new TaskToolCommandGenerator();
+    const tasks = await taskToolGen.loadTaskManifest(bmadDir);
+    const tools = await taskToolGen.loadToolManifest(bmadDir);
+
+    // Filter to only standalone items
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    // Generate command files for tasks with flat naming: bmad-task-{module}-{name}.md
+    for (const task of standaloneTasks) {
+      const commandContent = taskToolGen.generateCommandContent(task, 'task');
+      const targetPath = path.join(commandsBaseDir, `bmad-task-${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+    }
+
+    // Generate command files for tools with flat naming: bmad-tool-{module}-{name}.md
+    for (const tool of standaloneTools) {
+      const commandContent = taskToolGen.generateCommandContent(tool, 'tool');
+      const targetPath = path.join(commandsBaseDir, `bmad-tool-${tool.module}-${tool.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+    }
+
+    return {
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  async readAndProcess(filePath, metadata) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return this.processContent(content, metadata);
+  }
+
+  createAgentContent(content, metadata) {
+    const { frontmatter = {}, body } = this.parseFrontmatter(content);
+
+    frontmatter.description =
+      frontmatter.description && String(frontmatter.description).trim().length > 0
+        ? frontmatter.description
+        : `BMAD ${metadata.module} agent: ${metadata.name}`;
+
+    // OpenCode agents use: 'primary' mode for main agents
+    frontmatter.mode = 'primary';
+
+    const frontmatterString = this.stringifyFrontmatter(frontmatter);
+
+    return `${frontmatterString}\n${body}`;
+  }
+
+  parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+    if (!match) {
+      return { data: {}, body: content };
+    }
+
+    const body = content.slice(match[0].length);
+
+    let frontmatter = {};
+    try {
+      frontmatter = yaml.load(match[1]) || {};
+    } catch {
+      frontmatter = {};
+    }
+
+    return { frontmatter, body };
+  }
+
+  stringifyFrontmatter(frontmatter) {
+    const yamlText = yaml
+      .dump(frontmatter, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false,
+      })
+      .trimEnd();
+
+    return `---\n${yamlText}\n---`;
+  }
+
+  /**
+   * Cleanup OpenCode configuration - surgically remove only BMAD files
+   */
+  async cleanup(projectDir) {
+    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
+    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
+    let removed = 0;
+
+    // Clean up agent folder
+    if (await fs.pathExists(agentsDir)) {
+      const files = await fs.readdir(agentsDir);
+      for (const file of files) {
+        if (file.startsWith('bmad-') && file.endsWith('.md')) {
+          await fs.remove(path.join(agentsDir, file));
+          removed++;
+        }
+      }
+    }
+
+    // Clean up command folder
+    if (await fs.pathExists(commandsDir)) {
+      const files = await fs.readdir(commandsDir);
+      for (const file of files) {
+        if (file.startsWith('bmad-') && file.endsWith('.md')) {
+          await fs.remove(path.join(commandsDir, file));
+          removed++;
+        }
+      }
+    }
+
+    if (removed > 0) {
+      console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD files`));
+    }
+  }
+}
+
+module.exports = { OpenCodeSetup };