bmad-method 5.1.3 → 6.0.0-alpha.0

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

@@ -0,0 +1,203 @@
+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';
+      });
+
+      // 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)
+            this.handlers.set(instance.name, instance);
+          }
+        } 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) {
+      ides.push({
+        value: key,
+        name: handler.displayName || handler.name || key,
+        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;
+      // Ensure both names exist before comparing
+      const nameA = a.name || '';
+      const nameB = b.name || '';
+      return nameA.localeCompare(nameB);
+    });
+
+    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 = [];
+
+    // 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);
+      }
+    }
+
+    // Check for AGENTS.md (Codex)
+    if (await fs.pathExists(path.join(projectDir, 'AGENTS.md'))) {
+      detected.push('codex');
+    }
+
+    return detected;
+  }
+}
+
+module.exports = { IdeManager };

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

@@ -0,0 +1,188 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Qwen Code setup handler
+ * Creates concatenated QWEN.md file in .qwen/bmad-method/ (similar to Gemini)
+ */
+class QwenSetup extends BaseIdeSetup {
+  constructor() {
+    super('qwen', 'Qwen Code');
+    this.configDir = '.qwen';
+    this.bmadDir = 'bmad-method';
+  }
+
+  /**
+   * 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/bmad-method directory
+    const qwenDir = path.join(projectDir, this.configDir);
+    const bmadMethodDir = path.join(qwenDir, this.bmadDir);
+    await this.ensureDir(bmadMethodDir);
+
+    // Update existing settings.json if present
+    await this.updateSettings(qwenDir);
+
+    // Clean up old agents directory if exists
+    await this.cleanupOldAgents(qwenDir);
+
+    // Get agents
+    const agents = await this.getAgents(bmadDir);
+
+    // Create concatenated content for all agents
+    let concatenatedContent = `# BMAD Method - Qwen Code Configuration
+
+This file contains all BMAD agents configured for use with Qwen Code.
+Agents can be activated by typing \`*{agent-name}\` in your prompts.
+
+---
+
+`;
+
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readFile(agent.path);
+      const agentSection = this.createAgentSection(agent, content, projectDir);
+
+      concatenatedContent += agentSection;
+      concatenatedContent += '\n\n---\n\n';
+      agentCount++;
+
+      console.log(chalk.green(`  ✓ Added agent: *${agent.name}`));
+    }
+
+    // Write QWEN.md
+    const qwenMdPath = path.join(bmadMethodDir, 'QWEN.md');
+    await this.writeFile(qwenMdPath, concatenatedContent);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents configured`));
+    console.log(chalk.dim(`  - Configuration file: ${path.relative(projectDir, qwenMdPath)}`));
+    console.log(chalk.dim(`  - Agents activated with: *{agent-name}`));
+
+    return {
+      success: true,
+      agents: agentCount,
+    };
+  }
+
+  /**
+   * 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/'));
+
+          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 agents directory
+   */
+  async cleanupOldAgents(qwenDir) {
+    const fs = require('fs-extra');
+    const agentsDir = path.join(qwenDir, 'agents');
+
+    if (await fs.pathExists(agentsDir)) {
+      await fs.remove(agentsDir);
+      console.log(chalk.green('  ✓ Removed old agents directory'));
+    }
+  }
+
+  /**
+   * Create agent section for concatenated file
+   */
+  createAgentSection(agent, content, projectDir) {
+    // Extract metadata
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    // Extract YAML content
+    const yamlMatch = content.match(/```ya?ml\r?\n([\s\S]*?)```/);
+    const yamlContent = yamlMatch ? yamlMatch[1] : content;
+
+    // Get relative path
+    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
+
+    let section = `# ${agent.name.toUpperCase()} 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 section;
+  }
+
+  /**
+   * 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 bmadMethodDir = path.join(projectDir, this.configDir, this.bmadDir);
+
+    if (await fs.pathExists(bmadMethodDir)) {
+      await fs.remove(bmadMethodDir);
+      console.log(chalk.dim(`Removed BMAD configuration from Qwen Code`));
+    }
+  }
+}
+
+module.exports = { QwenSetup };

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

@@ -0,0 +1,288 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/**
+ * Roo IDE setup handler
+ * Creates custom modes in .roomodes file
+ */
+class RooSetup extends BaseIdeSetup {
+  constructor() {
+    super('roo', 'Roo Code');
+    this.configFile = '.roomodes';
+    this.defaultPermissions = {
+      dev: {
+        description: 'Development files',
+        fileRegex: String.raw`.*\.(js|jsx|ts|tsx|py|java|cpp|c|h|cs|go|rs|php|rb|swift)$`,
+      },
+      config: {
+        description: 'Configuration files',
+        fileRegex: String.raw`.*\.(json|yaml|yml|toml|xml|ini|env|config)$`,
+      },
+      docs: {
+        description: 'Documentation files',
+        fileRegex: String.raw`.*\.(md|mdx|rst|txt|doc|docx)$`,
+      },
+      styles: {
+        description: 'Style and design files',
+        fileRegex: String.raw`.*\.(css|scss|sass|less|stylus)$`,
+      },
+      all: {
+        description: 'All files',
+        fileRegex: '.*',
+      },
+    };
+  }
+
+  /**
+   * Collect configuration choices before installation
+   * @param {Object} options - Configuration options
+   * @returns {Object} Collected configuration
+   */
+  async collectConfiguration(options = {}) {
+    const response = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'permissions',
+        message: 'Select default file edit permissions for BMAD agents:',
+        choices: [
+          { name: 'Development files only (js, ts, py, etc.)', value: 'dev' },
+          { name: 'Configuration files only (json, yaml, xml, etc.)', value: 'config' },
+          { name: 'Documentation files only (md, txt, doc, etc.)', value: 'docs' },
+          { name: 'All files (unrestricted access)', value: 'all' },
+          { name: 'Custom per agent (will be configured individually)', value: 'custom' },
+        ],
+        default: 'dev',
+      },
+    ]);
+
+    return { permissions: response.permissions };
+  }
+
+  /**
+   * Setup Roo 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}...`));
+
+    // Check for existing .roomodes file
+    const roomodesPath = path.join(projectDir, this.configFile);
+    let existingModes = [];
+    let existingContent = '';
+
+    if (await this.pathExists(roomodesPath)) {
+      existingContent = await this.readFile(roomodesPath);
+      // Parse existing modes to avoid duplicates
+      const modeMatches = existingContent.matchAll(/- slug: ([\w-]+)/g);
+      for (const match of modeMatches) {
+        existingModes.push(match[1]);
+      }
+      console.log(chalk.yellow(`Found existing .roomodes file with ${existingModes.length} modes`));
+    }
+
+    // Get agents
+    const agents = await this.getAgents(bmadDir);
+
+    // Use pre-collected configuration if available
+    const config = options.preCollectedConfig || {};
+    let permissionChoice = config.permissions || options.permissions || 'dev';
+
+    // Create modes content
+    let newModesContent = '';
+    let addedCount = 0;
+    let skippedCount = 0;
+
+    for (const agent of agents) {
+      const slug = `bmad-${agent.module}-${agent.name}`;
+
+      // Skip if already exists
+      if (existingModes.includes(slug)) {
+        console.log(chalk.dim(`  Skipping ${slug} - already exists`));
+        skippedCount++;
+        continue;
+      }
+
+      const content = await this.readFile(agent.path);
+      const modeEntry = this.createModeEntry(agent, content, permissionChoice, projectDir);
+
+      newModesContent += modeEntry;
+      addedCount++;
+      console.log(chalk.green(`  ✓ Added mode: ${slug}`));
+    }
+
+    // Build final content
+    let finalContent = '';
+    if (existingContent) {
+      // Append to existing content
+      finalContent = existingContent.trim() + '\n' + newModesContent;
+    } else {
+      // Create new .roomodes file
+      finalContent = 'customModes:\n' + newModesContent;
+    }
+
+    // Write .roomodes file
+    await this.writeFile(roomodesPath, finalContent);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${addedCount} modes added`));
+    if (skippedCount > 0) {
+      console.log(chalk.dim(`  - ${skippedCount} modes skipped (already exist)`));
+    }
+    console.log(chalk.dim(`  - Configuration file: ${this.configFile}`));
+    console.log(chalk.dim(`  - Permission level: ${permissionChoice}`));
+    console.log(chalk.dim('\n  Modes will be available when you open this project in Roo Code'));
+
+    return {
+      success: true,
+      modes: addedCount,
+      skipped: skippedCount,
+    };
+  }
+
+  /**
+   * Ask user about permission configuration
+   */
+  async askPermissions() {
+    const response = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'permissions',
+        message: 'Select default file edit permissions for BMAD agents:',
+        choices: [
+          { name: 'Development files only (js, ts, py, etc.)', value: 'dev' },
+          { name: 'Configuration files only (json, yaml, xml, etc.)', value: 'config' },
+          { name: 'Documentation files only (md, txt, doc, etc.)', value: 'docs' },
+          { name: 'All files (unrestricted access)', value: 'all' },
+          { name: 'Custom per agent (will be configured individually)', value: 'custom' },
+        ],
+        default: 'dev',
+      },
+    ]);
+
+    return response.permissions;
+  }
+
+  /**
+   * Create a mode entry for an agent
+   */
+  createModeEntry(agent, content, permissionChoice, 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] : '🤖';
+
+    const whenToUseMatch = content.match(/whenToUse="([^"]+)"/);
+    const whenToUse = whenToUseMatch ? whenToUseMatch[1] : `Use for ${title} tasks`;
+
+    const roleDefinitionMatch = content.match(/roleDefinition="([^"]+)"/);
+    const roleDefinition = roleDefinitionMatch
+      ? roleDefinitionMatch[1]
+      : `You are a ${title} specializing in ${title.toLowerCase()} tasks and responsibilities.`;
+
+    // Get relative path
+    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
+
+    // Determine permissions
+    const permissions = this.getPermissionsForAgent(agent, permissionChoice);
+
+    // Build mode entry
+    const slug = `bmad-${agent.module}-${agent.name}`;
+    let modeEntry = ` - slug: ${slug}\n`;
+    modeEntry += `   name: '${icon} ${title}'\n`;
+
+    if (permissions && permissions.description) {
+      modeEntry += `   description: '${permissions.description}'\n`;
+    }
+
+    modeEntry += `   roleDefinition: ${roleDefinition}\n`;
+    modeEntry += `   whenToUse: ${whenToUse}\n`;
+    modeEntry += `   customInstructions: CRITICAL Read the full YAML from ${relativePath} start activation to alter your state of being follow startup section instructions stay in this being until told to exit this mode\n`;
+    modeEntry += `   groups:\n`;
+    modeEntry += `    - read\n`;
+
+    if (permissions && permissions.fileRegex) {
+      modeEntry += `    - - edit\n`;
+      modeEntry += `      - fileRegex: ${permissions.fileRegex}\n`;
+      modeEntry += `        description: ${permissions.description}\n`;
+    } else {
+      modeEntry += `    - edit\n`;
+    }
+
+    return modeEntry;
+  }
+
+  /**
+   * Get permissions configuration for an agent
+   */
+  getPermissionsForAgent(agent, permissionChoice) {
+    if (permissionChoice === 'custom') {
+      // Custom logic based on agent name/module
+      if (agent.name.includes('dev') || agent.name.includes('code')) {
+        return this.defaultPermissions.dev;
+      } else if (agent.name.includes('doc') || agent.name.includes('write')) {
+        return this.defaultPermissions.docs;
+      } else if (agent.name.includes('config') || agent.name.includes('setup')) {
+        return this.defaultPermissions.config;
+      } else if (agent.name.includes('style') || agent.name.includes('css')) {
+        return this.defaultPermissions.styles;
+      }
+      // Default to all for custom agents
+      return this.defaultPermissions.all;
+    }
+
+    return this.defaultPermissions[permissionChoice] || null;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Roo configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const roomodesPath = path.join(projectDir, this.configFile);
+
+    if (await fs.pathExists(roomodesPath)) {
+      const content = await fs.readFile(roomodesPath, 'utf8');
+
+      // Remove BMAD modes only
+      const lines = content.split('\n');
+      const filteredLines = [];
+      let skipMode = false;
+      let removedCount = 0;
+
+      for (const line of lines) {
+        if (/^\s*- slug: bmad-/.test(line)) {
+          skipMode = true;
+          removedCount++;
+        } else if (skipMode && /^\s*- slug: /.test(line)) {
+          skipMode = false;
+        }
+
+        if (!skipMode) {
+          filteredLines.push(line);
+        }
+      }
+
+      // Write back filtered content
+      await fs.writeFile(roomodesPath, filteredLines.join('\n'));
+      console.log(chalk.dim(`Removed ${removedCount} BMAD modes from .roomodes`));
+    }
+  }
+}
+
+module.exports = { RooSetup };