bmad-method 6.0.0-alpha.9 → 6.0.2

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

@@ -1,471 +0,0 @@
-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('./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
- */
-class ClaudeCodeSetup extends BaseIdeSetup {
-  constructor() {
-    super('claude-code', 'Claude Code', true); // preferred IDE
-    this.configDir = '.claude';
-    this.commandsDir = 'commands';
-    this.agentsDir = 'agents';
-  }
-
-  /**
-   * Collect configuration choices before installation
-   * @param {Object} options - Configuration options
-   * @returns {Object} Collected configuration
-   */
-  async collectConfiguration(options = {}) {
-    const config = {
-      subagentChoices: null,
-      installLocation: null,
-    };
-
-    const sourceModulesPath = getSourcePath('modules');
-    const modules = options.selectedModules || [];
-
-    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)) {
-        const fs = require('fs-extra');
-        const yaml = require('js-yaml');
-
-        try {
-          // Load injection configuration
-          const configContent = await fs.readFile(injectionConfigPath, 'utf8');
-          const injectionConfig = yaml.load(configContent);
-
-          // Ask about subagents if they exist and we haven't asked yet
-          if (injectionConfig.subagents && !config.subagentChoices) {
-            config.subagentChoices = await this.promptSubagentInstallation(injectionConfig.subagents);
-
-            if (config.subagentChoices.install !== 'none') {
-              // Ask for installation location
-              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',
-                },
-              ]);
-              config.installLocation = locationAnswer.location;
-            }
-          }
-        } catch (error) {
-          console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
-        }
-      }
-    }
-
-    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
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    // Store project directory for use in processContent
-    this.projectDir = projectDir;
-
-    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);
-    const bmadCommandsDir = path.join(commandsDir, 'bmad');
-
-    await this.ensureDir(bmadCommandsDir);
-
-    // 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 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'));
-    }
-
-    // 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, 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);
-    }
-
-    // Skip CLAUDE.md creation - let user manage their own CLAUDE.md file
-    // await this.createClaudeConfig(projectDir, modules);
-
-    // Generate workflow commands from manifest (if it exists)
-    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`));
-    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,
-    };
-  }
-
-  // Method removed - CLAUDE.md file management left to user
-
-  /**
-   * Read and process file content
-   */
-  async readAndProcess(filePath, metadata) {
-    const fs = require('fs-extra');
-    const content = await fs.readFile(filePath, 'utf8');
-    return this.processContent(content, metadata);
-  }
-
-  /**
-   * Override processContent to keep {project-root} placeholder
-   */
-  processContent(content, metadata = {}) {
-    // Use the base class method WITHOUT projectDir to preserve {project-root} placeholder
-    return super.processContent(content, metadata);
-  }
-
-  /**
-   * Get agents from source modules (not installed location)
-   */
-  async getAgentsFromSource(sourceDir, selectedModules) {
-    const fs = require('fs-extra');
-    const agents = [];
-
-    // Add core agents
-    const corePath = getModulePath('core');
-    if (await fs.pathExists(path.join(corePath, 'agents'))) {
-      const coreAgents = await getAgentsFromDir(path.join(corePath, 'agents'), 'core');
-      agents.push(...coreAgents);
-    }
-
-    // Add module agents
-    for (const moduleName of selectedModules) {
-      const modulePath = path.join(sourceDir, moduleName);
-      const agentsPath = path.join(modulePath, 'agents');
-
-      if (await fs.pathExists(agentsPath)) {
-        const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
-        agents.push(...moduleAgents);
-      }
-    }
-
-    return agents;
-  }
-
-  /**
-   * Process module injections with pre-collected configuration
-   */
-  async processModuleInjectionsWithConfig(projectDir, bmadDir, options, preCollectedConfig) {
-    // Get list of installed modules
-    const modules = options.selectedModules || [];
-    const { subagentChoices, installLocation } = preCollectedConfig;
-
-    // Get the actual source directory (not the installation directory)
-    await this.processModuleInjectionsInternal({
-      projectDir,
-      modules,
-      handler: 'claude-code',
-      subagentChoices,
-      installLocation,
-      interactive: false,
-    });
-  }
-
-  /**
-   * Process Claude Code specific injections for installed modules
-   * Looks for injections.yaml in each module's claude-code sub-module
-   */
-  async processModuleInjections(projectDir, bmadDir, options) {
-    // 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 { subagentChoices: updatedChoices, installLocation: updatedLocation } = await this.processModuleInjectionsInternal({
-      projectDir,
-      modules,
-      handler: 'claude-code',
-      subagentChoices,
-      installLocation,
-      interactive: true,
-    });
-
-    if (updatedChoices) {
-      subagentChoices = updatedChoices;
-    }
-    if (updatedLocation) {
-      installLocation = updatedLocation;
-    }
-  }
-
-  async processModuleInjectionsInternal({ projectDir, modules, handler, subagentChoices, installLocation, interactive = false }) {
-    let choices = subagentChoices;
-    let location = installLocation;
-
-    for (const moduleName of modules) {
-      const configData = await loadModuleInjectionConfig(handler, moduleName);
-
-      if (!configData) {
-        continue;
-      }
-
-      const { config, handlerBaseDir } = configData;
-
-      if (interactive) {
-        console.log(chalk.cyan(`\nConfiguring ${moduleName} ${handler.replace('-', ' ')} features...`));
-      }
-
-      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;
-        }
-      }
-
-      if (config.injections && choices && choices.install !== 'none') {
-        for (const injection of config.injections) {
-          if (shouldApplyInjection(injection, choices)) {
-            await this.injectContent(projectDir, injection, choices);
-          }
-        }
-      }
-
-      if (config.subagents && choices && choices.install !== 'none') {
-        await this.copySelectedSubagents(projectDir, handlerBaseDir, config.subagents, choices, location || 'project');
-      }
-    }
-
-    return { subagentChoices: choices, installLocation: location };
-  }
-
-  /**
-   * Prompt user for subagent installation preferences
-   */
-  async promptSubagentInstallation(subagentConfig) {
-    const inquirer = require('inquirer');
-
-    // First ask if they want to install subagents
-    const { install } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'install',
-        message: 'Would you like to install Claude Code subagents for enhanced functionality?',
-        choices: [
-          { name: 'Yes, install all subagents', value: 'all' },
-          { name: 'Yes, let me choose specific subagents', value: 'selective' },
-          { name: 'No, skip subagent installation', value: 'none' },
-        ],
-        default: 'all',
-      },
-    ]);
-
-    if (install === 'selective') {
-      // Show list of available subagents with descriptions
-      const subagentInfo = {
-        'market-researcher.md': 'Market research and competitive analysis',
-        'requirements-analyst.md': 'Requirements extraction and validation',
-        'technical-evaluator.md': 'Technology stack evaluation',
-        'epic-optimizer.md': 'Epic and story breakdown optimization',
-        'document-reviewer.md': 'Document quality review',
-      };
-
-      const { selected } = await inquirer.prompt([
-        {
-          type: 'checkbox',
-          name: 'selected',
-          message: 'Select subagents to install:',
-          choices: subagentConfig.files.map((file) => ({
-            name: `${file.replace('.md', '')} - ${subagentInfo[file] || 'Specialized assistant'}`,
-            value: file,
-            checked: true,
-          })),
-        },
-      ]);
-
-      return { install: 'selective', selected };
-    }
-
-    return { install };
-  }
-
-  /**
-   * Inject content at specified point in file
-   */
-  async injectContent(projectDir, injection, subagentChoices = null) {
-    const fs = require('fs-extra');
-    const targetPath = path.join(projectDir, injection.file);
-
-    if (await this.exists(targetPath)) {
-      let content = await fs.readFile(targetPath, 'utf8');
-      const marker = `<!-- IDE-INJECT-POINT: ${injection.point} -->`;
-
-      if (content.includes(marker)) {
-        let injectionContent = injection.content;
-
-        // Filter content if selective subagents chosen
-        if (subagentChoices && subagentChoices.install === 'selective' && injection.point === 'pm-agent-instructions') {
-          injectionContent = filterAgentInstructions(injection.content, subagentChoices.selected);
-        }
-
-        content = content.replace(marker, injectionContent);
-        await fs.writeFile(targetPath, content);
-        console.log(chalk.dim(`    Injected: ${injection.point} → ${injection.file}`));
-      }
-    }
-  }
-
-  /**
-   * Copy selected subagents to appropriate Claude agents directory
-   */
-  async copySelectedSubagents(projectDir, handlerBaseDir, subagentConfig, choices, location) {
-    const fs = require('fs-extra');
-    const os = require('node:os');
-
-    // Determine target directory based on user choice
-    let targetDir;
-    if (location === 'user') {
-      targetDir = path.join(os.homedir(), '.claude', 'agents');
-      console.log(chalk.dim(`  Installing subagents globally to: ~/.claude/agents/`));
-    } else {
-      targetDir = path.join(projectDir, '.claude', 'agents');
-      console.log(chalk.dim(`  Installing subagents to project: .claude/agents/`));
-    }
-
-    // Ensure target directory exists
-    await this.ensureDir(targetDir);
-
-    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));
-        }
-
-        await fs.copyFile(sourcePath, targetPath);
-        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 (copiedCount > 0) {
-      console.log(chalk.dim(`  Total subagents installed: ${copiedCount}`));
-    }
-  }
-}
-
-module.exports = { ClaudeCodeSetup };

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

@@ -1,220 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const chalk = require('chalk');
-const { BaseIdeSetup } = require('./_base-ide');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');
-
-/**
- * Cline IDE setup handler
- * Installs BMAD artifacts to .clinerules/workflows with flattened naming
- */
-class ClineSetup extends BaseIdeSetup {
-  constructor() {
-    super('cline', 'Cline', false);
-    this.configDir = '.clinerules';
-    this.workflowsDir = 'workflows';
-  }
-
-  /**
-   * Setup Cline 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}...`));
-
-    // Create .clinerules/workflows directory
-    const clineDir = path.join(projectDir, this.configDir);
-    const workflowsDir = path.join(clineDir, this.workflowsDir);
-
-    await this.ensureDir(workflowsDir);
-
-    // Clear old BMAD files
-    await this.clearOldBmadFiles(workflowsDir);
-
-    // Collect all artifacts
-    const { artifacts, counts } = await this.collectClineArtifacts(projectDir, bmadDir, options);
-
-    // Write flattened files
-    const written = await this.flattenAndWriteArtifacts(artifacts, workflowsDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${counts.agents} agents installed`));
-    console.log(chalk.dim(`  - ${counts.tasks} tasks installed`));
-    console.log(chalk.dim(`  - ${counts.workflows} workflow commands installed`));
-    if (counts.workflowLaunchers > 0) {
-      console.log(chalk.dim(`  - ${counts.workflowLaunchers} workflow launchers installed`));
-    }
-    console.log(chalk.dim(`  - ${written} files written to ${path.relative(projectDir, workflowsDir)}`));
-
-    // Usage instructions
-    console.log(chalk.yellow('\n  ⚠️  How to Use Cline Workflows'));
-    console.log(chalk.cyan('  BMAD workflows are available as slash commands in Cline'));
-    console.log(chalk.dim('  Usage:'));
-    console.log(chalk.dim('    - Type / to see available commands'));
-    console.log(chalk.dim('    - All BMAD items start with "bmad-"'));
-    console.log(chalk.dim('    - Example: /bmad-bmm-agents-pm'));
-
-    return {
-      success: true,
-      agents: counts.agents,
-      tasks: counts.tasks,
-      workflows: counts.workflows,
-      workflowLaunchers: counts.workflowLaunchers,
-      written,
-    };
-  }
-
-  /**
-   * Detect Cline installation by checking for .clinerules/workflows directory
-   */
-  async detect(projectDir) {
-    const workflowsDir = path.join(projectDir, this.configDir, this.workflowsDir);
-
-    if (!(await fs.pathExists(workflowsDir))) {
-      return false;
-    }
-
-    const entries = await fs.readdir(workflowsDir);
-    return entries.some((entry) => entry.startsWith('bmad-'));
-  }
-
-  /**
-   * Collect all artifacts for Cline export
-   */
-  async collectClineArtifacts(projectDir, bmadDir, options = {}) {
-    const selectedModules = options.selectedModules || [];
-    const artifacts = [];
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, selectedModules);
-
-    // Process agent launchers with project-specific paths
-    for (const agentArtifact of agentArtifacts) {
-      const content = agentArtifact.content;
-
-      artifacts.push({
-        type: 'agent',
-        module: agentArtifact.module,
-        sourcePath: agentArtifact.sourcePath,
-        relativePath: agentArtifact.relativePath,
-        content,
-      });
-    }
-
-    // Get tasks
-    const tasks = await getTasksFromBmad(bmadDir, selectedModules);
-    for (const task of tasks) {
-      const content = await this.readAndProcessWithProject(
-        task.path,
-        {
-          module: task.module,
-          name: task.name,
-        },
-        projectDir,
-      );
-
-      artifacts.push({
-        type: 'task',
-        module: task.module,
-        sourcePath: task.path,
-        relativePath: path.join(task.module, 'tasks', `${task.name}.md`),
-        content,
-      });
-    }
-
-    // Get workflows
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-    artifacts.push(...workflowArtifacts);
-
-    return {
-      artifacts,
-      counts: {
-        agents: agentArtifacts.length,
-        tasks: tasks.length,
-        workflows: workflowCounts.commands,
-        workflowLaunchers: workflowCounts.launchers,
-      },
-    };
-  }
-
-  /**
-   * Flatten file path to bmad-module-type-name.md format
-   */
-  flattenFilename(relativePath) {
-    const sanitized = relativePath.replaceAll(/[\\/]/g, '-');
-    return `bmad-${sanitized}`;
-  }
-
-  /**
-   * Write all artifacts with flattened names
-   */
-  async flattenAndWriteArtifacts(artifacts, destDir) {
-    let written = 0;
-
-    for (const artifact of artifacts) {
-      const flattenedName = this.flattenFilename(artifact.relativePath);
-      const targetPath = path.join(destDir, flattenedName);
-      await fs.writeFile(targetPath, artifact.content);
-      written++;
-    }
-
-    return written;
-  }
-
-  /**
-   * Clear old BMAD files from the workflows directory
-   */
-  async clearOldBmadFiles(destDir) {
-    if (!(await fs.pathExists(destDir))) {
-      return;
-    }
-
-    const entries = await fs.readdir(destDir);
-
-    for (const entry of entries) {
-      if (!entry.startsWith('bmad-')) {
-        continue;
-      }
-
-      const entryPath = path.join(destDir, entry);
-      const stat = await fs.stat(entryPath);
-      if (stat.isFile()) {
-        await fs.remove(entryPath);
-      } else if (stat.isDirectory()) {
-        await fs.remove(entryPath);
-      }
-    }
-  }
-
-  /**
-   * Read and process file with project-specific paths
-   */
-  async readAndProcessWithProject(filePath, metadata, projectDir) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return super.processContent(content, metadata, projectDir);
-  }
-
-  /**
-   * Cleanup Cline configuration
-   */
-  async cleanup(projectDir) {
-    const workflowsDir = path.join(projectDir, this.configDir, this.workflowsDir);
-    await this.clearOldBmadFiles(workflowsDir);
-    console.log(chalk.dim(`Removed ${this.name} BMAD configuration`));
-  }
-
-  /**
-   * Utility: Ensure directory exists
-   */
-  async ensureDir(dirPath) {
-    await fs.ensureDir(dirPath);
-  }
-}
-
-module.exports = { ClineSetup };