bmad-method 6.0.0-alpha.8 → 6.0.1

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

@@ -1,7 +1,10 @@
 const path = require('node:path');
 const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
+const yaml = require('yaml');
+const prompts = require('../../../lib/prompts');
 const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
 
 /**
  * KiloCode IDE setup handler
@@ -20,78 +23,93 @@ class KiloSetup extends BaseIdeSetup {
    * @param {Object} options - Setup options
    */
   async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
+    if (!options.silent) await prompts.log.info(`Setting up ${this.name}...`);
 
-    // Check for existing .kilocodemodes file
+    // Clean up any old BMAD installation first
+    await this.cleanup(projectDir, options);
+
+    // Load existing config (may contain non-BMAD modes and other settings)
     const kiloModesPath = path.join(projectDir, this.configFile);
-    let existingModes = [];
-    let existingContent = '';
+    let config = {};
 
     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]);
+      const existingContent = await this.readFile(kiloModesPath);
+      try {
+        config = yaml.parse(existingContent) || {};
+      } catch {
+        // If parsing fails, start fresh but warn user
+        await prompts.log.warn('Warning: Could not parse existing .kilocodemodes, starting fresh');
+        config = {};
       }
-      console.log(chalk.yellow(`Found existing .kilocodemodes file with ${existingModes.length} modes`));
+    }
+
+    // Ensure customModes array exists
+    if (!Array.isArray(config.customModes)) {
+      config.customModes = [];
     }
 
     // Generate agent launchers
     const agentGen = new AgentCommandGenerator(this.bmadFolderName);
     const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
 
-    // Create modes content
-    let newModesContent = '';
+    // Create mode objects and add to config
     let addedCount = 0;
-    let skippedCount = 0;
 
     for (const artifact of agentArtifacts) {
-      const slug = `bmad-${artifact.module}-${artifact.name}`;
+      const modeObject = await this.createModeObject(artifact, projectDir);
+      config.customModes.push(modeObject);
+      addedCount++;
+    }
 
-      // Skip if already exists
-      if (existingModes.includes(slug)) {
-        console.log(chalk.dim(`  Skipping ${slug} - already exists`));
-        skippedCount++;
-        continue;
-      }
+    // Write .kilocodemodes file with proper YAML structure
+    const finalContent = yaml.stringify(config, { lineWidth: 0 });
+    await this.writeFile(kiloModesPath, finalContent);
 
-      const modeEntry = await this.createModeEntry(artifact, projectDir);
+    // Generate workflow commands
+    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
+    const { artifacts: workflowArtifacts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
 
-      newModesContent += modeEntry;
-      addedCount++;
-    }
+    // Write to .kilocode/workflows/ directory
+    const workflowsDir = path.join(projectDir, '.kilocode', 'workflows');
+    await this.ensureDir(workflowsDir);
 
-    // Build final content
-    let finalContent = '';
-    if (existingContent) {
-      finalContent = existingContent.trim() + '\n' + newModesContent;
-    } else {
-      finalContent = 'customModes:\n' + newModesContent;
-    }
+    // Clear old BMAD workflows before writing new ones
+    await this.clearBmadWorkflows(workflowsDir);
 
-    // Write .kilocodemodes file
-    await this.writeFile(kiloModesPath, finalContent);
+    // Write workflow files
+    const workflowCount = await workflowGenerator.writeDashArtifacts(workflowsDir, workflowArtifacts);
 
-    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)`));
+    // Generate task and tool commands
+    const taskToolGen = new TaskToolCommandGenerator(this.bmadFolderName);
+    const { artifacts: taskToolArtifacts, counts: taskToolCounts } = await taskToolGen.collectTaskToolArtifacts(bmadDir);
+
+    // Write task/tool files to workflows directory (same location as workflows)
+    await taskToolGen.writeDashArtifacts(workflowsDir, taskToolArtifacts);
+    const taskCount = taskToolCounts.tasks || 0;
+    const toolCount = taskToolCounts.tools || 0;
+
+    if (!options.silent) {
+      await prompts.log.success(
+        `${this.name} configured: ${addedCount} modes, ${workflowCount} workflows, ${taskCount} tasks, ${toolCount} tools → ${this.configFile}`,
+      );
     }
-    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,
+      workflows: workflowCount,
+      tasks: taskCount,
+      tools: toolCount,
     };
   }
 
   /**
-   * Create a mode entry for an agent
+   * Create a mode object for an agent
+   * @param {Object} artifact - Agent artifact
+   * @param {string} projectDir - Project directory
+   * @returns {Object} Mode object for YAML serialization
    */
-  async createModeEntry(artifact, projectDir) {
+  async createModeObject(artifact, projectDir) {
     // Extract metadata from launcher content
     const titleMatch = artifact.content.match(/title="([^"]+)"/);
     const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
@@ -102,8 +120,8 @@ class KiloSetup extends BaseIdeSetup {
     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();
+    // Get the activation header from central template (trim to avoid YAML formatting issues)
+    const activationHeader = (await this.getAgentCommandHeader()).trim();
 
     const roleDefinitionMatch = artifact.content.match(/roleDefinition="([^"]+)"/);
     const roleDefinition = roleDefinitionMatch
@@ -113,18 +131,15 @@ class KiloSetup extends BaseIdeSetup {
     // 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: ${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`;
-
-    return modeEntry;
+    // Build mode object (KiloCode uses same schema as Roo)
+    return {
+      slug: `bmad-${artifact.module}-${artifact.name}`,
+      name: `${icon} ${title}`,
+      roleDefinition: roleDefinition,
+      whenToUse: whenToUse,
+      customInstructions: `${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`,
+      groups: ['read', 'edit', 'browser', 'command', 'mcp'],
+    };
   }
 
   /**
@@ -137,38 +152,117 @@ class KiloSetup extends BaseIdeSetup {
       .join(' ');
   }
 
+  /**
+   * Clear old BMAD workflow files from workflows directory
+   * @param {string} workflowsDir - Workflows directory path
+   */
+  async clearBmadWorkflows(workflowsDir) {
+    const fs = require('fs-extra');
+    if (!(await fs.pathExists(workflowsDir))) return;
+
+    const entries = await fs.readdir(workflowsDir);
+    for (const entry of entries) {
+      if (entry.startsWith('bmad-') && entry.endsWith('.md')) {
+        await fs.remove(path.join(workflowsDir, entry));
+      }
+    }
+  }
+
   /**
    * Cleanup KiloCode configuration
    */
-  async cleanup(projectDir) {
+  async cleanup(projectDir, options = {}) {
     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;
-        }
+      try {
+        const config = yaml.parse(content) || {};
 
-        if (!skipMode) {
-          filteredLines.push(line);
+        if (Array.isArray(config.customModes)) {
+          const originalCount = config.customModes.length;
+          // Remove BMAD modes only (keep non-BMAD modes)
+          config.customModes = config.customModes.filter((mode) => !mode.slug || !mode.slug.startsWith('bmad-'));
+          const removedCount = originalCount - config.customModes.length;
+
+          if (removedCount > 0) {
+            await fs.writeFile(kiloModesPath, yaml.stringify(config, { lineWidth: 0 }));
+            if (!options.silent) await prompts.log.message(`Removed ${removedCount} BMAD modes from .kilocodemodes`);
+          }
         }
+      } catch {
+        // If parsing fails, leave file as-is
+        if (!options.silent) await prompts.log.warn('Warning: Could not parse .kilocodemodes for cleanup');
+      }
+    }
+
+    // Clean up workflow files
+    const workflowsDir = path.join(projectDir, '.kilocode', 'workflows');
+    await this.clearBmadWorkflows(workflowsDir);
+  }
+
+  /**
+   * 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 config = {};
+
+    // Read existing .kilocodemodes file
+    if (await this.pathExists(kilocodemodesPath)) {
+      const existingContent = await this.readFile(kilocodemodesPath);
+      try {
+        config = yaml.parse(existingContent) || {};
+      } catch {
+        config = {};
       }
+    }
+
+    // Ensure customModes array exists
+    if (!Array.isArray(config.customModes)) {
+      config.customModes = [];
+    }
+
+    // Create custom agent mode object
+    const slug = `bmad-custom-${agentName.toLowerCase()}`;
 
-      await fs.writeFile(kiloModesPath, filteredLines.join('\n'));
-      console.log(chalk.dim(`Removed ${removedCount} BMAD modes from .kilocodemodes`));
+    // Check if mode already exists
+    if (config.customModes.some((mode) => mode.slug === slug)) {
+      return {
+        ide: 'kilo',
+        path: this.configFile,
+        command: agentName,
+        type: 'custom-agent-launcher',
+        alreadyExists: true,
+      };
     }
+
+    // Add custom mode object
+    config.customModes.push({
+      slug: slug,
+      name: `BMAD Custom: ${agentName}`,
+      description: `Custom BMAD agent: ${agentName}\n\n**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!\n\nThis is a launcher for the custom BMAD agent "${agentName}". The agent will follow the persona and instructions from the main agent file.\n`,
+      prompt: `@${agentPath}\n`,
+      always: false,
+      permissions: 'all',
+    });
+
+    // Write .kilocodemodes file with proper YAML structure
+    await this.writeFile(kilocodemodesPath, yaml.stringify(config, { lineWidth: 0 }));
+
+    return {
+      ide: 'kilo',
+      path: this.configFile,
+      command: slug,
+      type: 'custom-agent-launcher',
+    };
   }
 }
 

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

@@ -1,16 +1,21 @@
 const fs = require('fs-extra');
 const path = require('node:path');
-const chalk = require('chalk');
+const { BMAD_FOLDER_NAME } = require('./shared/path-utils');
+const prompts = require('../../../lib/prompts');
 
 /**
  * IDE Manager - handles IDE-specific setup
  * Dynamically discovers and loads IDE handlers
+ *
+ * Loading strategy:
+ * 1. Custom installer files (codex.js, github-copilot.js, kilo.js) - for platforms with unique installation logic
+ * 2. Config-driven handlers (from platform-codes.yaml) - for standard IDE installation patterns
  */
 class IdeManager {
   constructor() {
     this.handlers = new Map();
-    this.loadHandlers();
-    this.bmadFolderName = 'bmad'; // Default, can be overridden
+    this._initialized = false;
+    this.bmadFolderName = BMAD_FOLDER_NAME; // Default, can be overridden
   }
 
   /**
@@ -28,53 +33,81 @@ class IdeManager {
   }
 
   /**
-   * Dynamically load all IDE handlers from directory
+   * Ensure handlers are loaded (lazy loading)
    */
-  loadHandlers() {
-    const ideDir = __dirname;
+  async ensureInitialized() {
+    if (!this._initialized) {
+      await this.loadHandlers();
+      this._initialized = true;
+    }
+  }
 
-    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'
-        );
-      });
+  /**
+   * Dynamically load all IDE handlers
+   * 1. Load custom installer files first (codex.js, github-copilot.js, kilo.js)
+   * 2. Load config-driven handlers from platform-codes.yaml
+   */
+  async loadHandlers() {
+    // Load custom installer files
+    await this.loadCustomInstallerFiles();
 
-      // Sort alphabetically for consistent ordering
-      files.sort();
+    // Load config-driven handlers from platform-codes.yaml
+    await this.loadConfigDrivenHandlers();
+  }
 
-      for (const file of files) {
-        const moduleName = path.basename(file, '.js');
+  /**
+   * Load custom installer files (unique installation logic)
+   * These files have special installation patterns that don't fit the config-driven model
+   */
+  async loadCustomInstallerFiles() {
+    const ideDir = __dirname;
+    const customFiles = ['codex.js', 'github-copilot.js', 'kilo.js'];
 
-        try {
-          const modulePath = path.join(ideDir, file);
-          const HandlerModule = require(modulePath);
+    for (const file of customFiles) {
+      const filePath = path.join(ideDir, file);
+      if (!fs.existsSync(filePath)) continue;
 
-          // Get the first exported class (handles various export styles)
-          const HandlerClass = HandlerModule.default || HandlerModule[Object.keys(HandlerModule)[0]];
+      try {
+        const HandlerModule = require(filePath);
+        const HandlerClass = HandlerModule.default || Object.values(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`));
+        if (HandlerClass) {
+          const instance = new HandlerClass();
+          if (instance.name && typeof instance.name === 'string') {
+            if (typeof instance.setBmadFolderName === 'function') {
+              instance.setBmadFolderName(this.bmadFolderName);
             }
+            this.handlers.set(instance.name, instance);
           }
-        } catch (error) {
-          console.log(chalk.yellow(`  Warning: Could not load ${moduleName}: ${error.message}`));
         }
+      } catch (error) {
+        await prompts.log.warn(`Warning: Could not load ${file}: ${error.message}`);
       }
-    } catch (error) {
-      console.error(chalk.red('Failed to load IDE handlers:'), error.message);
+    }
+  }
+
+  /**
+   * Load config-driven handlers from platform-codes.yaml
+   * This creates ConfigDrivenIdeSetup instances for platforms with installer config
+   */
+  async loadConfigDrivenHandlers() {
+    const { loadPlatformCodes } = require('./platform-codes');
+    const platformConfig = await loadPlatformCodes();
+
+    const { ConfigDrivenIdeSetup } = require('./_config-driven');
+
+    for (const [platformCode, platformInfo] of Object.entries(platformConfig.platforms)) {
+      // Skip if already loaded by custom installer
+      if (this.handlers.has(platformCode)) continue;
+
+      // Skip if no installer config (platform may not need installation)
+      if (!platformInfo.installer) continue;
+
+      const handler = new ConfigDrivenIdeSetup(platformCode, platformInfo);
+      if (typeof handler.setBmadFolderName === 'function') {
+        handler.setBmadFolderName(this.bmadFolderName);
+      }
+      this.handlers.set(platformCode, handler);
     }
   }
 
@@ -138,30 +171,59 @@ class IdeManager {
     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' };
+      await prompts.log.warn(`IDE '${ideName}' is not yet supported`);
+      await prompts.log.message(`Supported IDEs: ${[...this.handlers.keys()].join(', ')}`);
+      return { success: false, ide: ideName, error: 'unsupported IDE' };
     }
 
     try {
-      await handler.setup(projectDir, bmadDir, options);
-      return { success: true, ide: ideName };
+      const handlerResult = await handler.setup(projectDir, bmadDir, options);
+      // Build detail string from handler-returned data
+      let detail = '';
+      if (handlerResult && handlerResult.results) {
+        // Config-driven handlers return { success, results: { agents, workflows, tasks, tools } }
+        const r = handlerResult.results;
+        const parts = [];
+        if (r.agents > 0) parts.push(`${r.agents} agents`);
+        if (r.workflows > 0) parts.push(`${r.workflows} workflows`);
+        if (r.tasks > 0) parts.push(`${r.tasks} tasks`);
+        if (r.tools > 0) parts.push(`${r.tools} tools`);
+        detail = parts.join(', ');
+      } else if (handlerResult && handlerResult.counts) {
+        // Codex handler returns { success, counts: { agents, workflows, tasks }, written }
+        const c = handlerResult.counts;
+        const parts = [];
+        if (c.agents > 0) parts.push(`${c.agents} agents`);
+        if (c.workflows > 0) parts.push(`${c.workflows} workflows`);
+        if (c.tasks > 0) parts.push(`${c.tasks} tasks`);
+        detail = parts.join(', ');
+      } else if (handlerResult && handlerResult.modes !== undefined) {
+        // Kilo handler returns { success, modes, workflows, tasks, tools }
+        const parts = [];
+        if (handlerResult.modes > 0) parts.push(`${handlerResult.modes} modes`);
+        if (handlerResult.workflows > 0) parts.push(`${handlerResult.workflows} workflows`);
+        if (handlerResult.tasks > 0) parts.push(`${handlerResult.tasks} tasks`);
+        if (handlerResult.tools > 0) parts.push(`${handlerResult.tools} tools`);
+        detail = parts.join(', ');
+      }
+      return { success: true, ide: ideName, detail, handlerResult };
     } catch (error) {
-      console.error(chalk.red(`Failed to setup ${ideName}:`), error.message);
-      return { success: false, error: error.message };
+      await prompts.log.error(`Failed to setup ${ideName}: ${error.message}`);
+      return { success: false, ide: ideName, error: error.message };
     }
   }
 
   /**
    * Cleanup IDE configurations
    * @param {string} projectDir - Project directory
+   * @param {Object} [options] - Cleanup options passed through to handlers
    */
-  async cleanup(projectDir) {
+  async cleanup(projectDir, options = {}) {
     const results = [];
 
     for (const [name, handler] of this.handlers) {
       try {
-        await handler.cleanup(projectDir);
+        await handler.cleanup(projectDir, options);
         results.push({ ide: name, success: true });
       } catch (error) {
         results.push({ ide: name, success: false, error: error.message });
@@ -171,6 +233,40 @@ class IdeManager {
     return results;
   }
 
+  /**
+   * Cleanup only the IDEs in the provided list
+   * Falls back to cleanup() (all handlers) if ideList is empty or undefined
+   * @param {string} projectDir - Project directory
+   * @param {Array<string>} ideList - List of IDE names to clean up
+   * @param {Object} [options] - Cleanup options passed through to handlers
+   * @returns {Array} Results array
+   */
+  async cleanupByList(projectDir, ideList, options = {}) {
+    if (!ideList || ideList.length === 0) {
+      return this.cleanup(projectDir, options);
+    }
+
+    await this.ensureInitialized();
+    const results = [];
+
+    // Build lowercase lookup for case-insensitive matching
+    const lowercaseHandlers = new Map([...this.handlers.entries()].map(([k, v]) => [k.toLowerCase(), v]));
+
+    for (const ideName of ideList) {
+      const handler = lowercaseHandlers.get(ideName.toLowerCase());
+      if (!handler) continue;
+
+      try {
+        await handler.cleanup(projectDir, options);
+        results.push({ ide: ideName, success: true });
+      } catch (error) {
+        results.push({ ide: ideName, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
   /**
    * Get list of supported IDEs
    * @returns {Array} List of supported IDE names
@@ -204,6 +300,41 @@ class IdeManager {
 
     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) {
+        await prompts.log.warn(`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) {
+        await prompts.log.warn(`Failed to install ${ideName} launcher: ${error.message}`);
+      }
+    }
+
+    return results;
+  }
 }
 
 module.exports = { IdeManager };