bmad-method 5.1.2 → 6.0.0-Beta.0

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

@@ -0,0 +1,250 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * 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`));
+    }
+
+    // Generate agent launchers
+    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
+
+    // Create modes content
+    let newModesContent = '';
+    let addedCount = 0;
+    let skippedCount = 0;
+
+    for (const artifact of agentArtifacts) {
+      const slug = `bmad-${artifact.module}-${artifact.name}`;
+
+      // Skip if already exists
+      if (existingModes.includes(slug)) {
+        console.log(chalk.dim(`  Skipping ${slug} - already exists`));
+        skippedCount++;
+        continue;
+      }
+
+      const modeEntry = await this.createModeEntry(artifact, 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
+   */
+  async createModeEntry(artifact, projectDir) {
+    // Extract metadata from launcher content
+    const titleMatch = artifact.content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
+
+    const iconMatch = artifact.content.match(/icon="([^"]+)"/);
+    const icon = iconMatch ? iconMatch[1] : '🤖';
+
+    const whenToUseMatch = artifact.content.match(/whenToUse="([^"]+)"/);
+    const whenToUse = whenToUseMatch ? whenToUseMatch[1] : `Use for ${title} tasks`;
+
+    // Get the activation header from central template
+    const activationHeader = await this.getAgentCommandHeader();
+
+    const roleDefinitionMatch = artifact.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, artifact.sourcePath).replaceAll('\\', '/');
+
+    // Build mode entry (KiloCode uses same schema as Roo)
+    const slug = `bmad-${artifact.module}-${artifact.name}`;
+    let modeEntry = ` - slug: ${slug}\n`;
+    modeEntry += `   name: '${icon} ${title}'\n`;
+    modeEntry += `   roleDefinition: ${roleDefinition}\n`;
+    modeEntry += `   whenToUse: ${whenToUse}\n`;
+    modeEntry += `   customInstructions: |\n`;
+    modeEntry += `    ${activationHeader} 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`;
+    modeEntry += `    - browser\n`;
+    modeEntry += `    - command\n`;
+    modeEntry += `    - mcp\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`));
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for Kilo
+   * @param {string} projectDir - Project directory
+   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
+   * @param {string} agentPath - Path to compiled agent (relative to project root)
+   * @param {Object} metadata - Agent metadata
+   * @returns {Object} Installation result
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    const kilocodemodesPath = path.join(projectDir, this.configFile);
+    let existingContent = '';
+
+    // Read existing .kilocodemodes file
+    if (await this.pathExists(kilocodemodesPath)) {
+      existingContent = await this.readFile(kilocodemodesPath);
+    }
+
+    // Create custom agent mode entry
+    const slug = `bmad-custom-${agentName.toLowerCase()}`;
+    const modeEntry = ` - slug: ${slug}
+   name: 'BMAD Custom: ${agentName}'
+   description: |
+    Custom BMAD agent: ${agentName}
+
+    **⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
+
+    This is a launcher for the custom BMAD agent "${agentName}". The agent will follow the persona and instructions from the main agent file.
+   prompt: |
+    @${agentPath}
+   always: false
+   permissions: all
+`;
+
+    // Check if mode already exists
+    if (existingContent.includes(slug)) {
+      return {
+        ide: 'kilo',
+        path: this.configFile,
+        command: agentName,
+        type: 'custom-agent-launcher',
+        alreadyExists: true,
+      };
+    }
+
+    // Build final content
+    let finalContent = '';
+    if (existingContent) {
+      // Find customModes section or add it
+      if (existingContent.includes('customModes:')) {
+        // Append to existing customModes
+        finalContent = existingContent + modeEntry;
+      } else {
+        // Add customModes section
+        finalContent = existingContent.trim() + '\n\ncustomModes:\n' + modeEntry;
+      }
+    } else {
+      // Create new .kilocodemodes file with customModes
+      finalContent = 'customModes:\n' + modeEntry;
+    }
+
+    // Write .kilocodemodes file
+    await this.writeFile(kilocodemodesPath, finalContent);
+
+    return {
+      ide: 'kilo',
+      path: this.configFile,
+      command: slug,
+      type: 'custom-agent-launcher',
+    };
+  }
+}
+
+module.exports = { KiloSetup };

package/tools/cli/installers/lib/ide/kiro-cli.js

@@ -0,0 +1,326 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+
+/**
+ * Kiro CLI setup handler for BMad Method
+ */
+class KiroCliSetup extends BaseIdeSetup {
+  constructor() {
+    super('kiro-cli', 'Kiro CLI', false);
+    this.configDir = '.kiro';
+    this.agentsDir = 'agents';
+  }
+
+  /**
+   * Cleanup old BMAD installation before reinstalling
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const bmadAgentsDir = path.join(projectDir, this.configDir, this.agentsDir);
+
+    if (await fs.pathExists(bmadAgentsDir)) {
+      // Remove existing BMad agents
+      const files = await fs.readdir(bmadAgentsDir);
+      for (const file of files) {
+        if (file.startsWith('bmad')) {
+          await fs.remove(path.join(bmadAgentsDir, file));
+        }
+      }
+      console.log(chalk.dim(`  Cleaned old BMAD agents from ${this.name}`));
+    }
+  }
+
+  /**
+   * Setup Kiro CLI configuration with BMad agents
+   * @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}...`));
+
+    await this.cleanup(projectDir);
+
+    const kiroDir = path.join(projectDir, this.configDir);
+    const agentsDir = path.join(kiroDir, this.agentsDir);
+
+    await this.ensureDir(agentsDir);
+
+    // Create BMad agents from source YAML files
+    await this.createBmadAgentsFromSource(agentsDir, projectDir);
+
+    console.log(chalk.green(`✓ ${this.name} configured with BMad agents`));
+  }
+
+  /**
+   * Create BMad agent definitions from source YAML files
+   * @param {string} agentsDir - Agents directory
+   * @param {string} projectDir - Project directory
+   */
+  async createBmadAgentsFromSource(agentsDir, projectDir) {
+    const sourceDir = path.join(__dirname, '../../../../../src/modules');
+
+    // Find all agent YAML files
+    const agentFiles = await this.findAgentFiles(sourceDir);
+
+    for (const agentFile of agentFiles) {
+      try {
+        await this.processAgentFile(agentFile, agentsDir, projectDir);
+      } catch (error) {
+        console.warn(chalk.yellow(`⚠️  Failed to process ${agentFile}: ${error.message}`));
+      }
+    }
+  }
+
+  /**
+   * Find all agent YAML files in modules and core
+   * @param {string} sourceDir - Source modules directory
+   * @returns {Array} Array of agent file paths
+   */
+  async findAgentFiles(sourceDir) {
+    const agentFiles = [];
+
+    // Check core agents
+    const coreAgentsDir = path.join(__dirname, '../../../../../src/core/agents');
+    if (await fs.pathExists(coreAgentsDir)) {
+      const files = await fs.readdir(coreAgentsDir);
+
+      for (const file of files) {
+        if (file.endsWith('.agent.yaml')) {
+          agentFiles.push(path.join(coreAgentsDir, file));
+        }
+      }
+    }
+
+    // Check module agents
+    if (!(await fs.pathExists(sourceDir))) {
+      return agentFiles;
+    }
+
+    const modules = await fs.readdir(sourceDir);
+
+    for (const module of modules) {
+      const moduleAgentsDir = path.join(sourceDir, module, 'agents');
+
+      if (await fs.pathExists(moduleAgentsDir)) {
+        const files = await fs.readdir(moduleAgentsDir);
+
+        for (const file of files) {
+          if (file.endsWith('.agent.yaml')) {
+            agentFiles.push(path.join(moduleAgentsDir, file));
+          }
+        }
+      }
+    }
+
+    return agentFiles;
+  }
+
+  /**
+   * Validate BMad Core compliance
+   * @param {Object} agentData - Agent YAML data
+   * @returns {boolean} True if compliant
+   */
+  validateBmadCompliance(agentData) {
+    const requiredFields = ['agent.metadata.id', 'agent.persona.role', 'agent.persona.principles'];
+
+    for (const field of requiredFields) {
+      const keys = field.split('.');
+      let current = agentData;
+
+      for (const key of keys) {
+        if (!current || !current[key]) {
+          return false;
+        }
+        current = current[key];
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Process individual agent YAML file
+   * @param {string} agentFile - Path to agent YAML file
+   * @param {string} agentsDir - Target agents directory
+   * @param {string} projectDir - Project directory
+   */
+  async processAgentFile(agentFile, agentsDir, projectDir) {
+    const yamlContent = await fs.readFile(agentFile, 'utf8');
+    const agentData = yaml.parse(yamlContent);
+
+    if (!this.validateBmadCompliance(agentData)) {
+      return;
+    }
+
+    // Extract module from file path
+    const normalizedPath = path.normalize(agentFile);
+    const pathParts = normalizedPath.split(path.sep);
+    const basename = path.basename(agentFile, '.agent.yaml');
+
+    // Find the module name from path
+    let moduleName = 'unknown';
+    if (pathParts.includes('src')) {
+      const srcIndex = pathParts.indexOf('src');
+      if (srcIndex + 3 < pathParts.length) {
+        const folderAfterSrc = pathParts[srcIndex + 1];
+        if (folderAfterSrc === 'core') {
+          moduleName = 'core';
+        } else if (folderAfterSrc === 'bmm') {
+          moduleName = 'bmm';
+        }
+      }
+    }
+
+    // Extract the agent name from the ID path in YAML if available
+    let agentBaseName = basename;
+    if (agentData.agent && agentData.agent.metadata && agentData.agent.metadata.id) {
+      const idPath = agentData.agent.metadata.id;
+      agentBaseName = path.basename(idPath, '.md');
+    }
+
+    const agentName = `bmad-${moduleName}-${agentBaseName}`;
+    const sanitizedAgentName = this.sanitizeAgentName(agentName);
+
+    // Create JSON definition
+    await this.createAgentDefinitionFromYaml(agentsDir, sanitizedAgentName, agentData);
+
+    // Create prompt file
+    await this.createAgentPromptFromYaml(agentsDir, sanitizedAgentName, agentData, projectDir);
+  }
+
+  /**
+   * Sanitize agent name for file naming
+   * @param {string} name - Agent name
+   * @returns {string} Sanitized name
+   */
+  sanitizeAgentName(name) {
+    return name
+      .toLowerCase()
+      .replaceAll(/\s+/g, '-')
+      .replaceAll(/[^a-z0-9-]/g, '');
+  }
+
+  /**
+   * Create agent JSON definition from YAML data
+   * @param {string} agentsDir - Agents directory
+   * @param {string} agentName - Agent name (role-based)
+   * @param {Object} agentData - Agent YAML data
+   */
+  async createAgentDefinitionFromYaml(agentsDir, agentName, agentData) {
+    const personName = agentData.agent.metadata.name;
+    const role = agentData.agent.persona.role;
+
+    const agentConfig = {
+      name: agentName,
+      description: `${personName} - ${role}`,
+      prompt: `file://./${agentName}-prompt.md`,
+      tools: ['*'],
+      mcpServers: {},
+      useLegacyMcpJson: true,
+      resources: [],
+    };
+
+    const agentPath = path.join(agentsDir, `${agentName}.json`);
+    await fs.writeJson(agentPath, agentConfig, { spaces: 2 });
+  }
+
+  /**
+   * Create agent prompt from YAML data
+   * @param {string} agentsDir - Agents directory
+   * @param {string} agentName - Agent name (role-based)
+   * @param {Object} agentData - Agent YAML data
+   * @param {string} projectDir - Project directory
+   */
+  async createAgentPromptFromYaml(agentsDir, agentName, agentData, projectDir) {
+    const promptPath = path.join(agentsDir, `${agentName}-prompt.md`);
+
+    // Generate prompt from YAML data
+    const prompt = this.generatePromptFromYaml(agentData);
+    await fs.writeFile(promptPath, prompt);
+  }
+
+  /**
+   * Generate prompt content from YAML data
+   * @param {Object} agentData - Agent YAML data
+   * @returns {string} Generated prompt
+   */
+  generatePromptFromYaml(agentData) {
+    const agent = agentData.agent;
+    const name = agent.metadata.name;
+    const icon = agent.metadata.icon || '🤖';
+    const role = agent.persona.role;
+    const identity = agent.persona.identity;
+    const style = agent.persona.communication_style;
+    const principles = agent.persona.principles;
+
+    let prompt = `# ${name} ${icon}\n\n`;
+    prompt += `## Role\n${role}\n\n`;
+
+    if (identity) {
+      prompt += `## Identity\n${identity}\n\n`;
+    }
+
+    if (style) {
+      prompt += `## Communication Style\n${style}\n\n`;
+    }
+
+    if (principles) {
+      prompt += `## Principles\n`;
+      if (typeof principles === 'string') {
+        // Handle multi-line string principles
+        prompt += principles + '\n\n';
+      } else if (Array.isArray(principles)) {
+        // Handle array principles
+        for (const principle of principles) {
+          prompt += `- ${principle}\n`;
+        }
+        prompt += '\n';
+      }
+    }
+
+    // Add menu items if available
+    if (agent.menu && agent.menu.length > 0) {
+      prompt += `## Available Workflows\n`;
+      for (let i = 0; i < agent.menu.length; i++) {
+        const item = agent.menu[i];
+        prompt += `${i + 1}. **${item.trigger}**: ${item.description}\n`;
+      }
+      prompt += '\n';
+    }
+
+    prompt += `## Instructions\nYou are ${name}, part of the BMad Method. Follow your role and principles while assisting users with their development needs.\n`;
+
+    return prompt;
+  }
+
+  /**
+   * Check if Kiro CLI is available
+   * @returns {Promise<boolean>} True if available
+   */
+  async isAvailable() {
+    try {
+      const { execSync } = require('node:child_process');
+      execSync('kiro-cli --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get installation instructions
+   * @returns {string} Installation instructions
+   */
+  getInstallInstructions() {
+    return `Install Kiro CLI:
+  curl -fsSL https://github.com/aws/kiro-cli/releases/latest/download/install.sh | bash
+  
+  Or visit: https://github.com/aws/kiro-cli`;
+  }
+}
+
+module.exports = { KiroCliSetup };