bmad-method 5.1.3 → 6.0.0-alpha.1

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

@@ -0,0 +1,194 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+
+/**
+ * IDE Manager - handles IDE-specific setup
+ * Dynamically discovers and loads IDE handlers
+ */
+class IdeManager {
+  constructor() {
+    this.handlers = new Map();
+    this.loadHandlers();
+  }
+
+  /**
+   * Dynamically load all IDE handlers from directory
+   */
+  loadHandlers() {
+    const ideDir = __dirname;
+
+    try {
+      // 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' &&
+          file !== 'task-tool-command-generator.js'
+        );
+      });
+
+      // Sort alphabetically for consistent ordering
+      files.sort();
+
+      for (const file of files) {
+        const moduleName = path.basename(file, '.js');
+
+        try {
+          const modulePath = path.join(ideDir, file);
+          const HandlerModule = require(modulePath);
+
+          // Get the first exported class (handles various export styles)
+          const HandlerClass = HandlerModule.default || HandlerModule[Object.keys(HandlerModule)[0]];
+
+          if (HandlerClass) {
+            const instance = new HandlerClass();
+            // Use the name property from the instance (set in constructor)
+            // 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}`));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to load IDE handlers:'), error.message);
+    }
+  }
+
+  /**
+   * Get all available IDEs with their metadata
+   * @returns {Array} Array of IDE information objects
+   */
+  getAvailableIdes() {
+    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: name,
+        preferred: handler.preferred || false,
+      });
+    }
+
+    // Sort: preferred first, then alphabetical
+    ides.sort((a, b) => {
+      if (a.preferred && !b.preferred) return -1;
+      if (!a.preferred && b.preferred) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return ides;
+  }
+
+  /**
+   * Get preferred IDEs
+   * @returns {Array} Array of preferred IDE information
+   */
+  getPreferredIdes() {
+    return this.getAvailableIdes().filter((ide) => ide.preferred);
+  }
+
+  /**
+   * Get non-preferred IDEs
+   * @returns {Array} Array of non-preferred IDE information
+   */
+  getOtherIdes() {
+    return this.getAvailableIdes().filter((ide) => !ide.preferred);
+  }
+
+  /**
+   * Setup IDE configuration
+   * @param {string} ideName - Name of the IDE
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(ideName, projectDir, bmadDir, options = {}) {
+    const handler = this.handlers.get(ideName.toLowerCase());
+
+    if (!handler) {
+      console.warn(chalk.yellow(`⚠️  IDE '${ideName}' is not yet supported`));
+      console.log(chalk.dim('Supported IDEs:', [...this.handlers.keys()].join(', ')));
+      return { success: false, reason: 'unsupported' };
+    }
+
+    try {
+      await handler.setup(projectDir, bmadDir, options);
+      return { success: true, ide: ideName };
+    } catch (error) {
+      console.error(chalk.red(`Failed to setup ${ideName}:`), error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Cleanup IDE configurations
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const results = [];
+
+    for (const [name, handler] of this.handlers) {
+      try {
+        await handler.cleanup(projectDir);
+        results.push({ ide: name, success: true });
+      } catch (error) {
+        results.push({ ide: name, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get list of supported IDEs
+   * @returns {Array} List of supported IDE names
+   */
+  getSupportedIdes() {
+    return [...this.handlers.keys()];
+  }
+
+  /**
+   * Check if an IDE is supported
+   * @param {string} ideName - Name of the IDE
+   * @returns {boolean} True if IDE is supported
+   */
+  isSupported(ideName) {
+    return this.handlers.has(ideName.toLowerCase());
+  }
+
+  /**
+   * Detect installed IDEs
+   * @param {string} projectDir - Project directory
+   * @returns {Array} List of detected IDEs
+   */
+  async detectInstalledIdes(projectDir) {
+    const detected = [];
+
+    for (const [name, handler] of this.handlers) {
+      if (typeof handler.detect === 'function' && (await handler.detect(projectDir))) {
+        detected.push(name);
+      }
+    }
+
+    return detected;
+  }
+}
+
+module.exports = { IdeManager };

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 };

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

@@ -0,0 +1,290 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');
+
+/**
+ * Qwen Code setup handler
+ * Creates TOML command files in .qwen/commands/BMad/
+ */
+class QwenSetup extends BaseIdeSetup {
+  constructor() {
+    super('qwen', 'Qwen Code');
+    this.configDir = '.qwen';
+    this.commandsDir = 'commands';
+    this.bmadDir = 'bmad';
+  }
+
+  /**
+   * Setup Qwen Code 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 .qwen/commands/BMad directory structure
+    const qwenDir = path.join(projectDir, this.configDir);
+    const commandsDir = path.join(qwenDir, this.commandsDir);
+    const bmadCommandsDir = path.join(commandsDir, this.bmadDir);
+
+    await this.ensureDir(bmadCommandsDir);
+
+    // Update existing settings.json if present
+    await this.updateSettings(qwenDir);
+
+    // Clean up old configuration if exists
+    await this.cleanupOldConfig(qwenDir);
+
+    // Get agents, tasks, tools, and workflows (standalone only for tools/workflows)
+    const agents = await getAgentsFromBmad(bmadDir, options.selectedModules || []);
+    const tasks = await getTasksFromBmad(bmadDir, options.selectedModules || []);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Create directories for each module (including standalone)
+    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(bmadCommandsDir, module));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'agents'));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'tasks'));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'tools'));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'workflows'));
+    }
+
+    // Create TOML files for each agent
+    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(bmadCommandsDir, agent.module, 'agents', `${agent.name}.toml`);
+
+      await this.writeFile(targetPath, content);
+
+      agentCount++;
+      console.log(chalk.green(`  ✓ Added agent: /bmad:${agent.module}:agents:${agent.name}`));
+    }
+
+    // Create TOML files for each task
+    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(bmadCommandsDir, task.module, 'tasks', `${task.name}.toml`);
+
+      await this.writeFile(targetPath, content);
+
+      taskCount++;
+      console.log(chalk.green(`  ✓ Added task: /bmad:${task.module}:tasks:${task.name}`));
+    }
+
+    // Create TOML files for each tool
+    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(bmadCommandsDir, tool.module, 'tools', `${tool.name}.toml`);
+
+      await this.writeFile(targetPath, content);
+
+      toolCount++;
+      console.log(chalk.green(`  ✓ Added tool: /bmad:${tool.module}:tools:${tool.name}`));
+    }
+
+    // Create TOML files for each workflow
+    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(bmadCommandsDir, workflow.module, 'workflows', `${workflow.name}.toml`);
+
+      await this.writeFile(targetPath, content);
+
+      workflowCount++;
+      console.log(chalk.green(`  ✓ Added workflow: /bmad:${workflow.module}:workflows:${workflow.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(`  - ${toolCount} tools configured`));
+    console.log(chalk.dim(`  - ${workflowCount} workflows configured`));
+    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, bmadCommandsDir)}`));
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Update settings.json to remove old agent references
+   */
+  async updateSettings(qwenDir) {
+    const fs = require('fs-extra');
+    const settingsPath = path.join(qwenDir, 'settings.json');
+
+    if (await fs.pathExists(settingsPath)) {
+      try {
+        const settingsContent = await fs.readFile(settingsPath, 'utf8');
+        const settings = JSON.parse(settingsContent);
+        let updated = false;
+
+        // Remove agent file references from contextFileName
+        if (settings.contextFileName && Array.isArray(settings.contextFileName)) {
+          const originalLength = settings.contextFileName.length;
+          settings.contextFileName = settings.contextFileName.filter(
+            (fileName) => !fileName.startsWith('agents/') && !fileName.startsWith('bmad-method/'),
+          );
+
+          if (settings.contextFileName.length !== originalLength) {
+            updated = true;
+          }
+        }
+
+        if (updated) {
+          await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+          console.log(chalk.green('  ✓ Updated .qwen/settings.json'));
+        }
+      } catch (error) {
+        console.warn(chalk.yellow('  ⚠ Could not update settings.json:'), error.message);
+      }
+    }
+  }
+
+  /**
+   * Clean up old configuration directories
+   */
+  async cleanupOldConfig(qwenDir) {
+    const fs = require('fs-extra');
+    const agentsDir = path.join(qwenDir, 'agents');
+    const bmadMethodDir = path.join(qwenDir, 'bmad-method');
+    const bmadDir = path.join(qwenDir, 'bmadDir');
+
+    if (await fs.pathExists(agentsDir)) {
+      await fs.remove(agentsDir);
+      console.log(chalk.green('  ✓ Removed old agents directory'));
+    }
+
+    if (await fs.pathExists(bmadMethodDir)) {
+      await fs.remove(bmadMethodDir);
+      console.log(chalk.green('  ✓ Removed old bmad-method directory'));
+    }
+
+    if (await fs.pathExists(bmadDir)) {
+      await fs.remove(bmadDir);
+      console.log(chalk.green('  ✓ Removed old BMad directory'));
+    }
+  }
+
+  /**
+   * 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 TOML metadata header for Qwen
+   * @param {string} content - File content
+   * @param {Object} metadata - File metadata
+   * @returns {string} Processed content with Qwen template
+   */
+  processContent(content, metadata = {}) {
+    // First apply base processing (includes activation injection for agents)
+    let prompt = super.processContent(content, metadata);
+
+    // 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 = '';
+
+    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}`;
+    } else if (isTask) {
+      // Extract task name if available
+      const nameMatch = content.match(/name="([^"]+)"/);
+      const taskName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Task: ${taskName}`;
+    } 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}`;
+    } else if (isWorkflow) {
+      // Workflow
+      description = `BMAD ${metadata.module.toUpperCase()} Workflow: ${metadata.name}`;
+    } else {
+      description = `BMAD ${metadata.module.toUpperCase()}: ${metadata.name}`;
+    }
+
+    return `description = "${description}"
+prompt = """
+${prompt}
+"""
+`;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Qwen configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, this.bmadDir);
+    const oldBmadMethodDir = path.join(projectDir, this.configDir, 'bmad-method');
+    const oldBMadDir = path.join(projectDir, this.configDir, 'BMad');
+
+    if (await fs.pathExists(bmadCommandsDir)) {
+      await fs.remove(bmadCommandsDir);
+      console.log(chalk.dim(`Removed BMAD configuration from Qwen Code`));
+    }
+
+    if (await fs.pathExists(oldBmadMethodDir)) {
+      await fs.remove(oldBmadMethodDir);
+      console.log(chalk.dim(`Removed old BMAD configuration from Qwen Code`));
+    }
+
+    if (await fs.pathExists(oldBMadDir)) {
+      await fs.remove(oldBMadDir);
+      console.log(chalk.dim(`Removed old BMAD configuration from Qwen Code`));
+    }
+  }
+}
+
+module.exports = { QwenSetup };