bmad-fh 6.0.0-alpha.052779ef

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-') || file.includes('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 };

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

@@ -0,0 +1,244 @@
+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();
+    this.bmadFolderName = 'bmad'; // Default, can be overridden
+  }
+
+  /**
+   * Set the bmad folder name for all IDE handlers
+   * @param {string} bmadFolderName - The bmad folder name
+   */
+  setBmadFolderName(bmadFolderName) {
+    this.bmadFolderName = bmadFolderName;
+    // Update all loaded handlers
+    for (const handler of this.handlers.values()) {
+      if (typeof handler.setBmadFolderName === 'function') {
+        handler.setBmadFolderName(bmadFolderName);
+      }
+    }
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Install custom agent launchers for specified IDEs
+   * @param {Array} ides - List of IDE names to install for
+   * @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} Results for each IDE
+   */
+  async installCustomAgentLaunchers(ides, projectDir, agentName, agentPath, metadata) {
+    const results = {};
+
+    for (const ideName of ides) {
+      const handler = this.handlers.get(ideName.toLowerCase());
+
+      if (!handler) {
+        console.warn(chalk.yellow(`⚠️  IDE '${ideName}' is not yet supported for custom agent installation`));
+        continue;
+      }
+
+      try {
+        if (typeof handler.installCustomAgentLauncher === 'function') {
+          const result = await handler.installCustomAgentLauncher(projectDir, agentName, agentPath, metadata);
+          if (result) {
+            results[ideName] = result;
+          }
+        }
+      } catch (error) {
+        console.warn(chalk.yellow(`⚠️  Failed to install ${ideName} launcher: ${error.message}`));
+      }
+    }
+
+    return results;
+  }
+}
+
+module.exports = { IdeManager };