bmad-method 5.1.2 → 6.0.0-alpha.0

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

@@ -0,0 +1,289 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/**
+ * GitHub Copilot setup handler
+ * Creates chat modes in .github/chatmodes/ and configures VS Code settings
+ */
+class GitHubCopilotSetup extends BaseIdeSetup {
+  constructor() {
+    super('github-copilot', 'GitHub Copilot', true); // preferred IDE
+    this.configDir = '.github';
+    this.chatmodesDir = 'chatmodes';
+    this.vscodeDir = '.vscode';
+  }
+
+  /**
+   * Collect configuration choices before installation
+   * @param {Object} options - Configuration options
+   * @returns {Object} Collected configuration
+   */
+  async collectConfiguration(options = {}) {
+    const config = {};
+
+    console.log('\n' + chalk.blue('  🔧 VS Code Settings Configuration'));
+    console.log(chalk.dim('  GitHub Copilot works best with specific settings\n'));
+
+    const response = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'configChoice',
+        message: 'How would you like to configure VS Code settings?',
+        choices: [
+          { name: 'Use recommended defaults (fastest)', value: 'defaults' },
+          { name: 'Configure each setting manually', value: 'manual' },
+          { name: 'Skip settings configuration', value: 'skip' },
+        ],
+        default: 'defaults',
+      },
+    ]);
+    config.vsCodeConfig = response.configChoice;
+
+    if (response.configChoice === 'manual') {
+      config.manualSettings = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'maxRequests',
+          message: 'Maximum requests per session (1-50)?',
+          default: '15',
+          validate: (input) => {
+            const num = parseInt(input);
+            return (num >= 1 && num <= 50) || 'Enter 1-50';
+          },
+        },
+        {
+          type: 'confirm',
+          name: 'runTasks',
+          message: 'Allow running workspace tasks?',
+          default: true,
+        },
+        {
+          type: 'confirm',
+          name: 'mcpDiscovery',
+          message: 'Enable MCP server discovery?',
+          default: true,
+        },
+        {
+          type: 'confirm',
+          name: 'autoFix',
+          message: 'Enable automatic error fixing?',
+          default: true,
+        },
+        {
+          type: 'confirm',
+          name: 'autoApprove',
+          message: 'Auto-approve tools (less secure)?',
+          default: false,
+        },
+      ]);
+    }
+
+    return config;
+  }
+
+  /**
+   * Setup GitHub Copilot 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}...`));
+
+    // Configure VS Code settings using pre-collected config if available
+    const config = options.preCollectedConfig || {};
+    await this.configureVsCodeSettings(projectDir, { ...options, ...config });
+
+    // Create .github/chatmodes directory
+    const githubDir = path.join(projectDir, this.configDir);
+    const chatmodesDir = path.join(githubDir, this.chatmodesDir);
+    await this.ensureDir(chatmodesDir);
+
+    // Get agents
+    const agents = await this.getAgents(bmadDir);
+
+    // Create chat mode files
+    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`);
+      await this.writeFile(targetPath, chatmodeContent);
+      modeCount++;
+
+      console.log(chalk.green(`  ✓ Created chat mode: ${agent.module}-${agent.name}`));
+    }
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${modeCount} chat modes created`));
+    console.log(chalk.dim(`  - Chat modes directory: ${path.relative(projectDir, chatmodesDir)}`));
+    console.log(chalk.dim(`  - VS Code settings configured`));
+    console.log(chalk.dim('\n  Chat modes available in VS Code Chat view'));
+
+    return {
+      success: true,
+      chatmodes: modeCount,
+      settings: true,
+    };
+  }
+
+  /**
+   * Configure VS Code settings for GitHub Copilot
+   */
+  async configureVsCodeSettings(projectDir, options) {
+    const fs = require('fs-extra');
+    const vscodeDir = path.join(projectDir, this.vscodeDir);
+    const settingsPath = path.join(vscodeDir, 'settings.json');
+
+    await this.ensureDir(vscodeDir);
+
+    // Read existing settings
+    let existingSettings = {};
+    if (await fs.pathExists(settingsPath)) {
+      try {
+        const content = await fs.readFile(settingsPath, 'utf8');
+        existingSettings = JSON.parse(content);
+        console.log(chalk.yellow('  Found existing .vscode/settings.json'));
+      } catch {
+        console.warn(chalk.yellow('  Could not parse settings.json, creating new'));
+      }
+    }
+
+    // Use pre-collected configuration or skip if not available
+    let configChoice = options.vsCodeConfig;
+    if (!configChoice) {
+      // If no pre-collected config, skip configuration
+      console.log(chalk.yellow('  ⚠ No configuration collected, skipping VS Code settings'));
+      return;
+    }
+
+    if (configChoice === 'skip') {
+      console.log(chalk.yellow('  ⚠ Skipping VS Code settings'));
+      return;
+    }
+
+    let bmadSettings = {};
+
+    if (configChoice === 'defaults') {
+      bmadSettings = {
+        'chat.agent.enabled': true,
+        'chat.agent.maxRequests': 15,
+        'github.copilot.chat.agent.runTasks': true,
+        'chat.mcp.discovery.enabled': true,
+        'github.copilot.chat.agent.autoFix': true,
+        'chat.tools.autoApprove': false,
+      };
+      console.log(chalk.green('  ✓ Using recommended defaults'));
+    } else {
+      // Manual configuration - use pre-collected settings
+      const manual = options.manualSettings || {};
+
+      bmadSettings = {
+        'chat.agent.enabled': true,
+        'chat.agent.maxRequests': parseInt(manual.maxRequests || 15),
+        'github.copilot.chat.agent.runTasks': manual.runTasks === undefined ? true : manual.runTasks,
+        'chat.mcp.discovery.enabled': manual.mcpDiscovery === undefined ? true : manual.mcpDiscovery,
+        'github.copilot.chat.agent.autoFix': manual.autoFix === undefined ? true : manual.autoFix,
+        'chat.tools.autoApprove': manual.autoApprove || false,
+      };
+    }
+
+    // Merge settings (existing take precedence)
+    const mergedSettings = { ...bmadSettings, ...existingSettings };
+
+    // Write settings
+    await fs.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+    console.log(chalk.green('  ✓ VS Code settings configured'));
+  }
+
+  /**
+   * Create chat mode content
+   */
+  createChatmodeContent(agent, content) {
+    // Extract metadata
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    const whenToUseMatch = content.match(/whenToUse="([^"]+)"/);
+    const description = whenToUseMatch ? whenToUseMatch[1] : `Activates the ${title} agent persona.`;
+
+    // Available GitHub Copilot tools
+    const tools = [
+      'changes',
+      'codebase',
+      'fetch',
+      'findTestFiles',
+      'githubRepo',
+      'problems',
+      'usages',
+      'editFiles',
+      'runCommands',
+      'runTasks',
+      'runTests',
+      'search',
+      'searchResults',
+      'terminalLastCommand',
+      'terminalSelection',
+      'testFailure',
+    ];
+
+    let chatmodeContent = `---
+description: "${description.replaceAll('"', String.raw`\"`)}"
+tools: ${JSON.stringify(tools)}
+---
+
+# ${title} Agent
+
+${content}
+
+## Module
+
+Part of the BMAD ${agent.module.toUpperCase()} module.
+`;
+
+    return chatmodeContent;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup GitHub Copilot configuration
+   */
+  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
+      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++;
+          }
+        }
+      }
+
+      console.log(chalk.dim(`Removed ${removed} BMAD chat modes from GitHub Copilot`));
+    }
+  }
+}
+
+module.exports = { GitHubCopilotSetup };

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

@@ -0,0 +1,142 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * iFlow CLI setup handler
+ * Creates commands in .iflow/commands/ directory structure
+ */
+class IFlowSetup extends BaseIdeSetup {
+  constructor() {
+    super('iflow', 'iFlow CLI');
+    this.configDir = '.iflow';
+    this.commandsDir = 'commands';
+  }
+
+  /**
+   * Setup iFlow CLI 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 .iflow/commands/bmad directory structure
+    const iflowDir = path.join(projectDir, this.configDir);
+    const commandsDir = path.join(iflowDir, this.commandsDir, 'bmad');
+    const agentsDir = path.join(commandsDir, 'agents');
+    const tasksDir = path.join(commandsDir, 'tasks');
+
+    await this.ensureDir(agentsDir);
+    await this.ensureDir(tasksDir);
+
+    // Get agents and tasks
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir);
+
+    // Setup agents as commands
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readFile(agent.path);
+      const commandContent = this.createAgentCommand(agent, content);
+
+      const targetPath = path.join(agentsDir, `${agent.module}-${agent.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+      agentCount++;
+    }
+
+    // Setup tasks as commands
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const commandContent = this.createTaskCommand(task, content);
+
+      const targetPath = path.join(tasksDir, `${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+      taskCount++;
+    }
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agent commands created`));
+    console.log(chalk.dim(`  - ${taskCount} task commands created`));
+    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+    };
+  }
+
+  /**
+   * Create agent command content
+   */
+  createAgentCommand(agent, content) {
+    // Extract metadata
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    let commandContent = `# /${agent.name} Command
+
+When this command is used, adopt the following agent persona:
+
+## ${title} Agent
+
+${content}
+
+## Usage
+
+This command activates the ${title} agent from the BMAD ${agent.module.toUpperCase()} module.
+
+## Module
+
+Part of the BMAD ${agent.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Create task command content
+   */
+  createTaskCommand(task, content) {
+    // Extract task name
+    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    let commandContent = `# /task-${task.name} Command
+
+When this command is used, execute the following task:
+
+## ${taskName} Task
+
+${content}
+
+## Usage
+
+This command executes the ${taskName} task from the BMAD ${task.module.toUpperCase()} module.
+
+## Module
+
+Part of the BMAD ${task.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Cleanup iFlow configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, 'bmad');
+
+    if (await fs.pathExists(bmadCommandsDir)) {
+      await fs.remove(bmadCommandsDir);
+      console.log(chalk.dim(`Removed BMAD commands from iFlow CLI`));
+    }
+  }
+}
+
+module.exports = { IFlowSetup };

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

@@ -0,0 +1,171 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * KiloCode IDE setup handler
+ * Creates custom modes in .kilocodemodes file (similar to Roo)
+ */
+class KiloSetup extends BaseIdeSetup {
+  constructor() {
+    super('kilo', 'Kilo Code');
+    this.configFile = '.kilocodemodes';
+  }
+
+  /**
+   * Setup KiloCode 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 .kilocodemodes file
+    const kiloModesPath = path.join(projectDir, this.configFile);
+    let existingModes = [];
+    let existingContent = '';
+
+    if (await this.pathExists(kiloModesPath)) {
+      existingContent = await this.readFile(kiloModesPath);
+      // Parse existing modes
+      const modeMatches = existingContent.matchAll(/- slug: ([\w-]+)/g);
+      for (const match of modeMatches) {
+        existingModes.push(match[1]);
+      }
+      console.log(chalk.yellow(`Found existing .kilocodemodes file with ${existingModes.length} modes`));
+    }
+
+    // Get agents
+    const agents = await this.getAgents(bmadDir);
+
+    // 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, projectDir);
+
+      newModesContent += modeEntry;
+      addedCount++;
+    }
+
+    // Build final content
+    let finalContent = '';
+    if (existingContent) {
+      finalContent = existingContent.trim() + '\n' + newModesContent;
+    } else {
+      finalContent = 'customModes:\n' + newModesContent;
+    }
+
+    // Write .kilocodemodes file
+    await this.writeFile(kiloModesPath, 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('\n  Modes will be available when you open this project in KiloCode'));
+
+    return {
+      success: true,
+      modes: addedCount,
+      skipped: skippedCount,
+    };
+  }
+
+  /**
+   * Create a mode entry for an agent
+   */
+  createModeEntry(agent, content, projectDir) {
+    // Extract metadata
+    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.`;
+
+    // Get relative path
+    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
+
+    // Build mode entry (KiloCode uses same schema as Roo)
+    const slug = `bmad-${agent.module}-${agent.name}`;
+    let modeEntry = ` - slug: ${slug}\n`;
+    modeEntry += `   name: '${icon} ${title}'\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`;
+    modeEntry += `    - edit\n`;
+
+    return modeEntry;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup KiloCode configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const kiloModesPath = path.join(projectDir, this.configFile);
+
+    if (await fs.pathExists(kiloModesPath)) {
+      const content = await fs.readFile(kiloModesPath, '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);
+        }
+      }
+
+      await fs.writeFile(kiloModesPath, filteredLines.join('\n'));
+      console.log(chalk.dim(`Removed ${removedCount} BMAD modes from .kilocodemodes`));
+    }
+  }
+}
+
+module.exports = { KiloSetup };