bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.10

package/tools/cli/installers/lib/ide/claude-code.js

@@ -2,7 +2,16 @@ const path = require('node:path');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { getProjectRoot, getSourcePath, getModulePath } = require('../../../lib/project-root');
-const { WorkflowCommandGenerator } = require('./workflow-command-generator');
+const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+const {
+  loadModuleInjectionConfig,
+  shouldApplyInjection,
+  filterAgentInstructions,
+  resolveSubagentFiles,
+} = require('./shared/module-injections');
+const { getAgentsFromBmad, getAgentsFromDir } = require('./shared/bmad-artifacts');
 
 /**
  * Claude Code IDE setup handler
@@ -73,6 +82,20 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     return config;
   }
 
+  /**
+   * Cleanup old BMAD installation before reinstalling
+   * @param {string} projectDir - Project directory
+   */
+  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 old BMAD commands from ${this.name}`));
+    }
+  }
+
   /**
    * Setup Claude Code IDE configuration
    * @param {string} projectDir - Project directory
@@ -85,6 +108,9 @@ class ClaudeCodeSetup extends BaseIdeSetup {
 
     console.log(chalk.cyan(`Setting up ${this.name}...`));
 
+    // Clean up old BMAD installation first
+    await this.cleanup(projectDir);
+
     // Create .claude/commands directory structure
     const claudeDir = path.join(projectDir, this.configDir);
     const commandsDir = path.join(claudeDir, this.commandsDir);
@@ -92,53 +118,32 @@ class ClaudeCodeSetup extends BaseIdeSetup {
 
     await this.ensureDir(bmadCommandsDir);
 
-    // Get agents and tasks from SOURCE, not installed location
-    // This ensures we process files with {project-root} placeholders intact
-    const sourceDir = getSourcePath('modules');
-    const agents = await this.getAgentsFromSource(sourceDir, options.selectedModules || []);
-    const tasks = await this.getTasksFromSource(sourceDir, options.selectedModules || []);
+    // Generate agent launchers using AgentCommandGenerator
+    // This creates small launcher files that reference the actual agents in .bmad/
+    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+    const { artifacts: agentArtifacts, counts: agentCounts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
 
     // Create directories for each module
     const modules = new Set();
-    for (const item of [...agents, ...tasks]) modules.add(item.module);
+    for (const artifact of agentArtifacts) {
+      modules.add(artifact.module);
+    }
 
     for (const module of modules) {
       await this.ensureDir(path.join(bmadCommandsDir, module));
       await this.ensureDir(path.join(bmadCommandsDir, module, 'agents'));
-      await this.ensureDir(path.join(bmadCommandsDir, module, 'tasks'));
     }
 
-    // Process and copy agents
-    let agentCount = 0;
-    for (const agent of agents) {
-      const content = await this.readAndProcess(agent.path, {
-        module: agent.module,
-        name: agent.name,
-      });
-
-      const targetPath = path.join(bmadCommandsDir, agent.module, 'agents', `${agent.name}.md`);
-
-      await this.writeFile(targetPath, content);
-      agentCount++;
-    }
-
-    // Process and copy tasks
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readAndProcess(task.path, {
-        module: task.module,
-        name: task.name,
-      });
-
-      const targetPath = path.join(bmadCommandsDir, task.module, 'tasks', `${task.name}.md`);
-
-      await this.writeFile(targetPath, content);
-      taskCount++;
-    }
+    // Write agent launcher files
+    const agentCount = await agentGen.writeAgentLaunchers(bmadCommandsDir, agentArtifacts);
 
     // Process Claude Code specific injections for installed modules
-    // Use pre-collected configuration if available
-    if (options.preCollectedConfig) {
+    // Use pre-collected configuration if available, or skip if already configured
+    if (options.preCollectedConfig && options.preCollectedConfig._alreadyConfigured) {
+      // IDE is already configured from previous installation, skip prompting
+      // Just process with default/existing configuration
+      await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, {});
+    } else if (options.preCollectedConfig) {
       await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, options.preCollectedConfig);
     } else {
       await this.processModuleInjections(projectDir, bmadDir, options);
@@ -148,21 +153,43 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     // await this.createClaudeConfig(projectDir, modules);
 
     // Generate workflow commands from manifest (if it exists)
-    const workflowGen = new WorkflowCommandGenerator();
-    const workflowResult = await workflowGen.generateWorkflowCommands(projectDir, bmadDir);
+    const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
+    const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
+
+    // Write only workflow-command artifacts, skip workflow-launcher READMEs
+    let workflowCommandCount = 0;
+    for (const artifact of workflowArtifacts) {
+      if (artifact.type === 'workflow-command') {
+        const moduleWorkflowsDir = path.join(bmadCommandsDir, artifact.module, 'workflows');
+        await this.ensureDir(moduleWorkflowsDir);
+        const commandPath = path.join(moduleWorkflowsDir, path.basename(artifact.relativePath));
+        await this.writeFile(commandPath, artifact.content);
+        workflowCommandCount++;
+      }
+      // Skip workflow-launcher READMEs as they would be treated as slash commands
+    }
+
+    // Generate task and tool commands from manifests (if they exist)
+    const taskToolGen = new TaskToolCommandGenerator();
+    const taskToolResult = await taskToolGen.generateTaskToolCommands(projectDir, bmadDir);
 
     console.log(chalk.green(`✓ ${this.name} configured:`));
     console.log(chalk.dim(`  - ${agentCount} agents installed`));
-    console.log(chalk.dim(`  - ${taskCount} tasks installed`));
-    if (workflowResult.generated > 0) {
-      console.log(chalk.dim(`  - ${workflowResult.generated} workflow commands generated`));
+    if (workflowCommandCount > 0) {
+      console.log(chalk.dim(`  - ${workflowCommandCount} workflow commands generated`));
+    }
+    if (taskToolResult.generated > 0) {
+      console.log(
+        chalk.dim(
+          `  - ${taskToolResult.generated} task/tool commands generated (${taskToolResult.tasks} tasks, ${taskToolResult.tools} tools)`,
+        ),
+      );
     }
     console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, bmadCommandsDir)}`));
 
     return {
       success: true,
       agents: agentCount,
-      tasks: taskCount,
     };
   }
 
@@ -178,11 +205,11 @@ class ClaudeCodeSetup extends BaseIdeSetup {
   }
 
   /**
-   * Override processContent to use the actual project directory path
+   * Override processContent to keep {project-root} placeholder
    */
   processContent(content, metadata = {}) {
-    // Use the base class method with the actual project directory
-    return super.processContent(content, metadata, this.projectDir);
+    // Use the base class method WITHOUT projectDir to preserve {project-root} placeholder
+    return super.processContent(content, metadata);
   }
 
   /**
@@ -195,7 +222,7 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     // Add core agents
     const corePath = getModulePath('core');
     if (await fs.pathExists(path.join(corePath, 'agents'))) {
-      const coreAgents = await this.getAgentsFromDir(path.join(corePath, 'agents'), 'core');
+      const coreAgents = await getAgentsFromDir(path.join(corePath, 'agents'), 'core');
       agents.push(...coreAgents);
     }
 
@@ -205,7 +232,7 @@ class ClaudeCodeSetup extends BaseIdeSetup {
       const agentsPath = path.join(modulePath, 'agents');
 
       if (await fs.pathExists(agentsPath)) {
-        const moduleAgents = await this.getAgentsFromDir(agentsPath, moduleName);
+        const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
         agents.push(...moduleAgents);
       }
     }
@@ -213,133 +240,23 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     return agents;
   }
 
-  /**
-   * Get tasks from source modules (not installed location)
-   */
-  async getTasksFromSource(sourceDir, selectedModules) {
-    const fs = require('fs-extra');
-    const tasks = [];
-
-    // Add core tasks
-    const corePath = getModulePath('core');
-    if (await fs.pathExists(path.join(corePath, 'tasks'))) {
-      const coreTasks = await this.getTasksFromDir(path.join(corePath, 'tasks'), 'core');
-      tasks.push(...coreTasks);
-    }
-
-    // Add module tasks
-    for (const moduleName of selectedModules) {
-      const modulePath = path.join(sourceDir, moduleName);
-      const tasksPath = path.join(modulePath, 'tasks');
-
-      if (await fs.pathExists(tasksPath)) {
-        const moduleTasks = await this.getTasksFromDir(tasksPath, moduleName);
-        tasks.push(...moduleTasks);
-      }
-    }
-
-    return tasks;
-  }
-
-  /**
-   * Get agents from a specific directory
-   */
-  async getAgentsFromDir(dirPath, moduleName) {
-    const fs = require('fs-extra');
-    const agents = [];
-
-    const files = await fs.readdir(dirPath);
-    for (const file of files) {
-      if (file.endsWith('.md')) {
-        const filePath = path.join(dirPath, file);
-        const content = await fs.readFile(filePath, 'utf8');
-
-        // Skip web-only agents
-        if (content.includes('localskip="true"')) {
-          continue;
-        }
-
-        agents.push({
-          path: filePath,
-          name: file.replace('.md', ''),
-          module: moduleName,
-        });
-      }
-    }
-
-    return agents;
-  }
-
-  /**
-   * Get tasks from a specific directory
-   */
-  async getTasksFromDir(dirPath, moduleName) {
-    const fs = require('fs-extra');
-    const tasks = [];
-
-    const files = await fs.readdir(dirPath);
-    for (const file of files) {
-      if (file.endsWith('.md')) {
-        tasks.push({
-          path: path.join(dirPath, file),
-          name: file.replace('.md', ''),
-          module: moduleName,
-        });
-      }
-    }
-
-    return tasks;
-  }
-
   /**
    * Process module injections with pre-collected configuration
    */
   async processModuleInjectionsWithConfig(projectDir, bmadDir, options, preCollectedConfig) {
-    const fs = require('fs-extra');
-    const yaml = require('js-yaml');
-
     // Get list of installed modules
     const modules = options.selectedModules || [];
     const { subagentChoices, installLocation } = preCollectedConfig;
 
     // Get the actual source directory (not the installation directory)
-    const sourceModulesPath = getSourcePath('modules');
-
-    for (const moduleName of modules) {
-      // Check for Claude Code sub-module injection config in SOURCE directory
-      const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');
-
-      if (await this.exists(injectionConfigPath)) {
-        try {
-          // Load injection configuration
-          const configContent = await fs.readFile(injectionConfigPath, 'utf8');
-          const config = yaml.load(configContent);
-
-          // Process content injections based on user choices
-          if (config.injections && subagentChoices && subagentChoices.install !== 'none') {
-            for (const injection of config.injections) {
-              // Check if this injection is related to a selected subagent
-              if (this.shouldInject(injection, subagentChoices)) {
-                await this.injectContent(projectDir, injection, subagentChoices);
-              }
-            }
-          }
-
-          // Copy selected subagents
-          if (config.subagents && subagentChoices && subagentChoices.install !== 'none') {
-            await this.copySelectedSubagents(
-              projectDir,
-              path.dirname(injectionConfigPath),
-              config.subagents,
-              subagentChoices,
-              installLocation,
-            );
-          }
-        } catch (error) {
-          console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
-        }
-      }
-    }
+    await this.processModuleInjectionsInternal({
+      projectDir,
+      modules,
+      handler: 'claude-code',
+      subagentChoices,
+      installLocation,
+      interactive: false,
+    });
   }
 
   /**
@@ -347,77 +264,81 @@ class ClaudeCodeSetup extends BaseIdeSetup {
    * Looks for injections.yaml in each module's claude-code sub-module
    */
   async processModuleInjections(projectDir, bmadDir, options) {
-    const fs = require('fs-extra');
-    const yaml = require('js-yaml');
-    const inquirer = require('inquirer');
-
     // Get list of installed modules
     const modules = options.selectedModules || [];
     let subagentChoices = null;
     let installLocation = null;
 
     // Get the actual source directory (not the installation directory)
-    const sourceModulesPath = getSourcePath('modules');
+    const { subagentChoices: updatedChoices, installLocation: updatedLocation } = await this.processModuleInjectionsInternal({
+      projectDir,
+      modules,
+      handler: 'claude-code',
+      subagentChoices,
+      installLocation,
+      interactive: true,
+    });
+
+    if (updatedChoices) {
+      subagentChoices = updatedChoices;
+    }
+    if (updatedLocation) {
+      installLocation = updatedLocation;
+    }
+  }
 
-    for (const moduleName of modules) {
-      // Check for Claude Code sub-module injection config in SOURCE directory
-      const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');
+  async processModuleInjectionsInternal({ projectDir, modules, handler, subagentChoices, installLocation, interactive = false }) {
+    let choices = subagentChoices;
+    let location = installLocation;
 
-      if (await this.exists(injectionConfigPath)) {
-        console.log(chalk.cyan(`\nConfiguring ${moduleName} Claude Code features...`));
+    for (const moduleName of modules) {
+      const configData = await loadModuleInjectionConfig(handler, moduleName);
 
-        try {
-          // Load injection configuration
-          const configContent = await fs.readFile(injectionConfigPath, 'utf8');
-          const config = yaml.load(configContent);
+      if (!configData) {
+        continue;
+      }
 
-          // Ask about subagents if they exist and we haven't asked yet
-          if (config.subagents && !subagentChoices) {
-            subagentChoices = await this.promptSubagentInstallation(config.subagents);
+      const { config, handlerBaseDir } = configData;
 
-            if (subagentChoices.install !== 'none') {
-              // Ask for installation location
-              const locationAnswer = await inquirer.prompt([
-                {
-                  type: 'list',
-                  name: 'location',
-                  message: 'Where would you like to install Claude Code subagents?',
-                  choices: [
-                    { name: 'Project level (.claude/agents/)', value: 'project' },
-                    { name: 'User level (~/.claude/agents/)', value: 'user' },
-                  ],
-                  default: 'project',
-                },
-              ]);
-              installLocation = locationAnswer.location;
-            }
-          }
+      if (interactive) {
+        console.log(chalk.cyan(`\nConfiguring ${moduleName} ${handler.replace('-', ' ')} features...`));
+      }
 
-          // Process content injections based on user choices
-          if (config.injections && subagentChoices && subagentChoices.install !== 'none') {
-            for (const injection of config.injections) {
-              // Check if this injection is related to a selected subagent
-              if (this.shouldInject(injection, subagentChoices)) {
-                await this.injectContent(projectDir, injection, subagentChoices);
-              }
-            }
-          }
+      if (interactive && config.subagents && !choices) {
+        choices = await this.promptSubagentInstallation(config.subagents);
+
+        if (choices.install !== 'none') {
+          const inquirer = require('inquirer');
+          const locationAnswer = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'location',
+              message: 'Where would you like to install Claude Code subagents?',
+              choices: [
+                { name: 'Project level (.claude/agents/)', value: 'project' },
+                { name: 'User level (~/.claude/agents/)', value: 'user' },
+              ],
+              default: 'project',
+            },
+          ]);
+          location = locationAnswer.location;
+        }
+      }
 
-          // Copy selected subagents
-          if (config.subagents && subagentChoices && subagentChoices.install !== 'none') {
-            await this.copySelectedSubagents(
-              projectDir,
-              path.dirname(injectionConfigPath),
-              config.subagents,
-              subagentChoices,
-              installLocation,
-            );
+      if (config.injections && choices && choices.install !== 'none') {
+        for (const injection of config.injections) {
+          if (shouldApplyInjection(injection, choices)) {
+            await this.injectContent(projectDir, injection, choices);
           }
-        } catch (error) {
-          console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
         }
       }
+
+      if (config.subagents && choices && choices.install !== 'none') {
+        await this.copySelectedSubagents(projectDir, handlerBaseDir, config.subagents, choices, location || 'project');
+      }
     }
+
+    return { subagentChoices: choices, installLocation: location };
   }
 
   /**
@@ -470,45 +391,6 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     return { install };
   }
 
-  /**
-   * Check if an injection should be applied based on user choices
-   */
-  shouldInject(injection, subagentChoices) {
-    // If user chose no subagents, no injections
-    if (subagentChoices.install === 'none') {
-      return false;
-    }
-
-    // If user chose all subagents, all injections apply
-    if (subagentChoices.install === 'all') {
-      return true;
-    }
-
-    // For selective installation, check the 'requires' field
-    if (subagentChoices.install === 'selective') {
-      // If injection requires 'any' subagent and user selected at least one
-      if (injection.requires === 'any' && subagentChoices.selected.length > 0) {
-        return true;
-      }
-
-      // Check if the required subagent was selected
-      if (injection.requires) {
-        const requiredAgent = injection.requires + '.md';
-        return subagentChoices.selected.includes(requiredAgent);
-      }
-
-      // Fallback: check if injection mentions a selected agent
-      const selectedAgentNames = subagentChoices.selected.map((f) => f.replace('.md', ''));
-      for (const agentName of selectedAgentNames) {
-        if (injection.point && injection.point.includes(agentName)) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
   /**
    * Inject content at specified point in file
    */
@@ -525,7 +407,7 @@ class ClaudeCodeSetup extends BaseIdeSetup {
 
         // Filter content if selective subagents chosen
         if (subagentChoices && subagentChoices.install === 'selective' && injection.point === 'pm-agent-instructions') {
-          injectionContent = this.filterAgentInstructions(injection.content, subagentChoices.selected);
+          injectionContent = filterAgentInstructions(injection.content, subagentChoices.selected);
         }
 
         content = content.replace(marker, injectionContent);
@@ -535,59 +417,17 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     }
   }
 
-  /**
-   * Filter agent instructions to only include selected subagents
-   */
-  filterAgentInstructions(content, selectedFiles) {
-    const selectedAgents = selectedFiles.map((f) => f.replace('.md', ''));
-    const lines = content.split('\n');
-    const filteredLines = [];
-
-    let includeNextLine = true;
-    for (const line of lines) {
-      // Always include structural lines
-      if (line.includes('<llm') || line.includes('</llm>')) {
-        filteredLines.push(line);
-        includeNextLine = true;
-      }
-      // Check if line mentions a subagent
-      else if (line.includes('subagent')) {
-        let shouldInclude = false;
-        for (const agent of selectedAgents) {
-          if (line.includes(agent)) {
-            shouldInclude = true;
-            break;
-          }
-        }
-        if (shouldInclude) {
-          filteredLines.push(line);
-        }
-      }
-      // Include general instructions
-      else if (line.includes('When creating PRDs') || line.includes('ACTIVELY delegate')) {
-        filteredLines.push(line);
-      }
-    }
-
-    // Only return content if we have actual instructions
-    if (filteredLines.length > 2) {
-      // More than just llm tags
-      return filteredLines.join('\n');
-    }
-    return ''; // Return empty if no relevant content
-  }
-
   /**
    * Copy selected subagents to appropriate Claude agents directory
    */
-  async copySelectedSubagents(projectDir, moduleClaudeDir, subagentConfig, choices, location) {
+  async copySelectedSubagents(projectDir, handlerBaseDir, subagentConfig, choices, location) {
     const fs = require('fs-extra');
-    const sourceDir = path.join(moduleClaudeDir, subagentConfig.source);
+    const os = require('node:os');
 
     // Determine target directory based on user choice
     let targetDir;
     if (location === 'user') {
-      targetDir = path.join(require('node:os').homedir(), '.claude', 'agents');
+      targetDir = path.join(os.homedir(), '.claude', 'agents');
       console.log(chalk.dim(`  Installing subagents globally to: ~/.claude/agents/`));
     } else {
       targetDir = path.join(projectDir, '.claude', 'agents');
@@ -597,27 +437,33 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     // Ensure target directory exists
     await this.ensureDir(targetDir);
 
-    // Determine which files to copy
-    let filesToCopy = [];
-    if (choices.install === 'all') {
-      filesToCopy = subagentConfig.files;
-    } else if (choices.install === 'selective') {
-      filesToCopy = choices.selected;
-    }
-
-    // Copy selected subagent files
-    for (const file of filesToCopy) {
-      const sourcePath = path.join(sourceDir, file);
-      const targetPath = path.join(targetDir, file);
+    const resolvedFiles = await resolveSubagentFiles(handlerBaseDir, subagentConfig, choices);
+
+    let copiedCount = 0;
+    for (const resolved of resolvedFiles) {
+      try {
+        const sourcePath = resolved.absolutePath;
+
+        const subFolder = path.dirname(resolved.relativePath);
+        let targetPath;
+        if (subFolder && subFolder !== '.') {
+          const targetSubDir = path.join(targetDir, subFolder);
+          await this.ensureDir(targetSubDir);
+          targetPath = path.join(targetSubDir, path.basename(resolved.file));
+        } else {
+          targetPath = path.join(targetDir, path.basename(resolved.file));
+        }
 
-      if (await this.exists(sourcePath)) {
         await fs.copyFile(sourcePath, targetPath);
-        console.log(chalk.green(`    ✓ Installed: ${file.replace('.md', '')}`));
+        console.log(chalk.green(`    ✓ Installed: ${subFolder === '.' ? '' : `${subFolder}/`}${path.basename(resolved.file, '.md')}`));
+        copiedCount++;
+      } catch (error) {
+        console.log(chalk.yellow(`    ⚠ Error copying ${resolved.file}: ${error.message}`));
       }
     }
 
-    if (filesToCopy.length > 0) {
-      console.log(chalk.dim(`  Total subagents installed: ${filesToCopy.length}`));
+    if (copiedCount > 0) {
+      console.log(chalk.dim(`  Total subagents installed: ${copiedCount}`));
     }
   }
 }