bmad-method 5.1.3 → 6.0.0-Beta.0

package/tools/cli/installers/lib/ide/shared/module-injections.js

@@ -0,0 +1,136 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+const { glob } = require('glob');
+const { getSourcePath } = require('../../../../lib/project-root');
+
+async function loadModuleInjectionConfig(handler, moduleName) {
+  const sourceModulesPath = getSourcePath('modules');
+  const handlerBaseDir = path.join(sourceModulesPath, moduleName, 'sub-modules', handler);
+  const configPath = path.join(handlerBaseDir, 'injections.yaml');
+
+  if (!(await fs.pathExists(configPath))) {
+    return null;
+  }
+
+  const configContent = await fs.readFile(configPath, 'utf8');
+  const config = yaml.parse(configContent) || {};
+
+  return {
+    config,
+    handlerBaseDir,
+    configPath,
+  };
+}
+
+function shouldApplyInjection(injection, subagentChoices) {
+  if (!subagentChoices || subagentChoices.install === 'none') {
+    return false;
+  }
+
+  if (subagentChoices.install === 'all') {
+    return true;
+  }
+
+  if (subagentChoices.install === 'selective') {
+    const selected = subagentChoices.selected || [];
+
+    if (injection.requires === 'any' && selected.length > 0) {
+      return true;
+    }
+
+    if (injection.requires) {
+      const required = `${injection.requires}.md`;
+      return selected.includes(required);
+    }
+
+    if (injection.point) {
+      const selectedNames = selected.map((file) => file.replace('.md', ''));
+      return selectedNames.some((name) => injection.point.includes(name));
+    }
+  }
+
+  return false;
+}
+
+function filterAgentInstructions(content, selectedFiles) {
+  if (!selectedFiles || selectedFiles.length === 0) {
+    return '';
+  }
+
+  const selectedAgents = selectedFiles.map((file) => file.replace('.md', ''));
+  const lines = content.split('\n');
+  const filteredLines = [];
+
+  for (const line of lines) {
+    if (line.includes('<llm') || line.includes('</llm>')) {
+      filteredLines.push(line);
+    } 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);
+      }
+    } else if (line.includes('When creating PRDs') || line.includes('ACTIVELY delegate')) {
+      filteredLines.push(line);
+    }
+  }
+
+  if (filteredLines.length > 2) {
+    return filteredLines.join('\n');
+  }
+
+  return '';
+}
+
+async function resolveSubagentFiles(handlerBaseDir, subagentConfig, subagentChoices) {
+  if (!subagentConfig || !subagentConfig.files) {
+    return [];
+  }
+
+  if (!subagentChoices || subagentChoices.install === 'none') {
+    return [];
+  }
+
+  let filesToCopy = subagentConfig.files;
+
+  if (subagentChoices.install === 'selective') {
+    filesToCopy = subagentChoices.selected || [];
+  }
+
+  const sourceDir = path.join(handlerBaseDir, subagentConfig.source || '');
+  const resolved = [];
+
+  for (const file of filesToCopy) {
+    // Use forward slashes for glob pattern (works on both Windows and Unix)
+    // Convert backslashes to forward slashes for glob compatibility
+    const normalizedSourceDir = sourceDir.replaceAll('\\', '/');
+    const pattern = `${normalizedSourceDir}/**/${file}`;
+    const matches = await glob(pattern);
+
+    if (matches.length > 0) {
+      const absolutePath = matches[0];
+      resolved.push({
+        file,
+        absolutePath,
+        relativePath: path.relative(sourceDir, absolutePath),
+        sourceDir,
+      });
+    }
+  }
+
+  return resolved;
+}
+
+module.exports = {
+  loadModuleInjectionConfig,
+  shouldApplyInjection,
+  filterAgentInstructions,
+  resolveSubagentFiles,
+};

package/tools/cli/installers/lib/ide/shared/path-utils.js

@@ -0,0 +1,165 @@
+/**
+ * Path transformation utilities for IDE installer standardization
+ *
+ * Provides utilities to convert hierarchical paths to flat naming conventions.
+ * - Underscore format (bmad_module_name.md) - Windows-compatible universal format
+ */
+
+// Type segments - agents are included in naming, others are filtered out
+const TYPE_SEGMENTS = ['workflows', 'tasks', 'tools'];
+const AGENT_SEGMENT = 'agents';
+
+/**
+ * Convert hierarchical path to flat underscore-separated name
+ * Converts: 'bmm', 'agents', 'pm' → 'bmad_bmm_agent_pm.md'
+ * Converts: 'bmm', 'workflows', 'correct-course' → 'bmad_bmm_correct-course.md'
+ * Converts: 'core', 'agents', 'brainstorming' → 'bmad_agent_brainstorming.md' (core items skip module prefix)
+ *
+ * @param {string} module - Module name (e.g., 'bmm', 'core')
+ * @param {string} type - Artifact type ('agents', 'workflows', 'tasks', 'tools')
+ * @param {string} name - Artifact name (e.g., 'pm', 'brainstorming')
+ * @returns {string} Flat filename like 'bmad_bmm_agent_pm.md' or 'bmad_bmm_correct-course.md'
+ */
+function toUnderscoreName(module, type, name) {
+  const isAgent = type === AGENT_SEGMENT;
+  // For core module, skip the module prefix: use 'bmad_name.md' instead of 'bmad_core_name.md'
+  if (module === 'core') {
+    return isAgent ? `bmad_agent_${name}.md` : `bmad_${name}.md`;
+  }
+  return isAgent ? `bmad_${module}_agent_${name}.md` : `bmad_${module}_${name}.md`;
+}
+
+/**
+ * Convert relative path to flat underscore-separated name
+ * Converts: 'bmm/agents/pm.md' → 'bmad_bmm_agent_pm.md'
+ * Converts: 'bmm/workflows/correct-course.md' → 'bmad_bmm_correct-course.md'
+ * Converts: 'core/agents/brainstorming.md' → 'bmad_agent_brainstorming.md' (core items skip module prefix)
+ *
+ * @param {string} relativePath - Path like 'bmm/agents/pm.md'
+ * @returns {string} Flat filename like 'bmad_bmm_agent_pm.md' or 'bmad_brainstorming.md'
+ */
+function toUnderscorePath(relativePath) {
+  const withoutExt = relativePath.replace('.md', '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1];
+  const name = parts.slice(2).join('_');
+
+  // Use toUnderscoreName for consistency
+  return toUnderscoreName(module, type, name);
+}
+
+/**
+ * Create custom agent underscore name
+ * Creates: 'bmad_custom_fred-commit-poet.md'
+ *
+ * @param {string} agentName - Custom agent name
+ * @returns {string} Flat filename like 'bmad_custom_fred-commit-poet.md'
+ */
+function customAgentUnderscoreName(agentName) {
+  return `bmad_custom_${agentName}.md`;
+}
+
+/**
+ * Check if a filename uses underscore format
+ * @param {string} filename - Filename to check
+ * @returns {boolean} True if filename uses underscore format
+ */
+function isUnderscoreFormat(filename) {
+  return filename.startsWith('bmad_') && filename.includes('_');
+}
+
+/**
+ * Extract parts from an underscore-formatted filename
+ * Parses: 'bmad_bmm_agent_pm.md' → { prefix: 'bmad', module: 'bmm', type: 'agents', name: 'pm' }
+ * Parses: 'bmad_bmm_correct-course.md' → { prefix: 'bmad', module: 'bmm', type: 'workflows', name: 'correct-course' }
+ * Parses: 'bmad_agent_brainstorming.md' → { prefix: 'bmad', module: 'core', type: 'agents', name: 'brainstorming' } (core agents)
+ * Parses: 'bmad_brainstorming.md' → { prefix: 'bmad', module: 'core', type: 'workflows', name: 'brainstorming' } (core workflows)
+ *
+ * @param {string} filename - Underscore-formatted filename
+ * @returns {Object|null} Parsed parts or null if invalid format
+ */
+function parseUnderscoreName(filename) {
+  const withoutExt = filename.replace('.md', '');
+  const parts = withoutExt.split('_');
+
+  if (parts.length < 2 || parts[0] !== 'bmad') {
+    return null;
+  }
+
+  // Check if this is an agent file (has 'agent' as one of the parts)
+  const agentIndex = parts.indexOf('agent');
+
+  if (agentIndex !== -1) {
+    // This is an agent file
+    // Format: bmad_agent_name (core) or bmad_module_agent_name
+    if (agentIndex === 1) {
+      // Core agent: bmad_agent_name
+      return {
+        prefix: parts[0],
+        module: 'core',
+        type: 'agents',
+        name: parts.slice(agentIndex + 1).join('_'),
+      };
+    } else {
+      // Module agent: bmad_module_agent_name
+      return {
+        prefix: parts[0],
+        module: parts[1],
+        type: 'agents',
+        name: parts.slice(agentIndex + 1).join('_'),
+      };
+    }
+  }
+
+  // Not an agent file - must be a workflow/tool/task
+  // If only 2 parts (bmad_name), it's a core workflow/tool/task
+  if (parts.length === 2) {
+    return {
+      prefix: parts[0],
+      module: 'core',
+      type: 'workflows', // Default to workflows for non-agent core items
+      name: parts[1],
+    };
+  }
+
+  // Otherwise, it's a module workflow/tool/task (bmad_module_name)
+  return {
+    prefix: parts[0],
+    module: parts[1],
+    type: 'workflows', // Default to workflows for non-agent module items
+    name: parts.slice(2).join('_'),
+  };
+}
+
+// Backward compatibility aliases (deprecated)
+const toColonName = toUnderscoreName;
+const toColonPath = toUnderscorePath;
+const toDashPath = toUnderscorePath;
+const customAgentColonName = customAgentUnderscoreName;
+const customAgentDashName = customAgentUnderscoreName;
+const isColonFormat = isUnderscoreFormat;
+const isDashFormat = isUnderscoreFormat;
+const parseColonName = parseUnderscoreName;
+const parseDashName = parseUnderscoreName;
+
+module.exports = {
+  toUnderscoreName,
+  toUnderscorePath,
+  customAgentUnderscoreName,
+  isUnderscoreFormat,
+  parseUnderscoreName,
+  // Backward compatibility aliases
+  toColonName,
+  toColonPath,
+  toDashPath,
+  customAgentColonName,
+  customAgentDashName,
+  isColonFormat,
+  isDashFormat,
+  parseColonName,
+  parseDashName,
+  TYPE_SEGMENTS,
+  AGENT_SEGMENT,
+};

package/tools/cli/installers/lib/ide/shared/task-tool-command-generator.js

@@ -0,0 +1,268 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const chalk = require('chalk');
+const { toColonName, toColonPath, toDashPath } = require('./path-utils');
+
+/**
+ * Generates command files for standalone tasks and tools
+ */
+class TaskToolCommandGenerator {
+  /**
+   * Generate task and tool commands from manifest CSVs
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} baseCommandsDir - Optional base commands directory (defaults to .claude/commands/bmad)
+   */
+  async generateTaskToolCommands(projectDir, bmadDir, baseCommandsDir = null) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    // Filter to only standalone items
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    // Base commands directory - use provided or default to Claude Code structure
+    const commandsDir = baseCommandsDir || path.join(projectDir, '.claude', 'commands', 'bmad');
+
+    let generatedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of standaloneTasks) {
+      const moduleTasksDir = path.join(commandsDir, task.module, 'tasks');
+      await fs.ensureDir(moduleTasksDir);
+
+      const commandContent = this.generateCommandContent(task, 'task');
+      const commandPath = path.join(moduleTasksDir, `${task.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of standaloneTools) {
+      const moduleToolsDir = path.join(commandsDir, tool.module, 'tools');
+      await fs.ensureDir(moduleToolsDir);
+
+      const commandContent = this.generateCommandContent(tool, 'tool');
+      const commandPath = path.join(moduleToolsDir, `${tool.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  /**
+   * Generate command content for a task or tool
+   */
+  generateCommandContent(item, type) {
+    const description = item.description || `Execute ${item.displayName || item.name}`;
+
+    // Convert path to use {project-root} placeholder
+    let itemPath = item.path;
+    if (itemPath.startsWith('bmad/')) {
+      itemPath = `{project-root}/${itemPath}`;
+    }
+
+    return `---
+description: '${description.replaceAll("'", "''")}'
+---
+
+# ${item.displayName || item.name}
+
+LOAD and execute the ${type} at: ${itemPath}
+
+Follow all instructions in the ${type} file exactly as written.
+`;
+  }
+
+  /**
+   * Load task manifest CSV
+   */
+  async loadTaskManifest(bmadDir) {
+    const manifestPath = path.join(bmadDir, '_config', 'task-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+  }
+
+  /**
+   * Load tool manifest CSV
+   */
+  async loadToolManifest(bmadDir) {
+    const manifestPath = path.join(bmadDir, '_config', 'tool-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+  }
+
+  /**
+   * Generate task and tool commands using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_bmad-help.md
+   *
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @returns {Object} Generation results
+   */
+  async generateColonTaskToolCommands(projectDir, bmadDir, baseCommandsDir) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    // Filter to only standalone items
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    let generatedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of standaloneTasks) {
+      const commandContent = this.generateCommandContent(task, 'task');
+      // Use underscore format: bmad_bmm_name.md
+      const flatName = toColonName(task.module, 'tasks', task.name);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of standaloneTools) {
+      const commandContent = this.generateCommandContent(tool, 'tool');
+      // Use underscore format: bmad_bmm_name.md
+      const flatName = toColonName(tool.module, 'tools', tool.name);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  /**
+   * Generate task and tool commands using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_bmad-help.md
+   *
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @returns {Object} Generation results
+   */
+  async generateDashTaskToolCommands(projectDir, bmadDir, baseCommandsDir) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    // Filter to only standalone items
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    let generatedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of standaloneTasks) {
+      const commandContent = this.generateCommandContent(task, 'task');
+      // Use underscore format: bmad_bmm_name.md
+      const flatName = toDashPath(`${task.module}/tasks/${task.name}.md`);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of standaloneTools) {
+      const commandContent = this.generateCommandContent(tool, 'tool');
+      // Use underscore format: bmad_bmm_name.md
+      const flatName = toDashPath(`${tool.module}/tools/${tool.name}.md`);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  /**
+   * Write task/tool artifacts using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_bmad-help.md
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Task/tool artifacts with relativePath
+   * @returns {number} Count of commands written
+   */
+  async writeColonArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'task' || artifact.type === 'tool') {
+        const commandContent = this.generateCommandContent(artifact, artifact.type);
+        // Use underscore format: bmad_module_name.md
+        const flatName = toColonPath(artifact.relativePath);
+        const commandPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(commandPath));
+        await fs.writeFile(commandPath, commandContent);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+
+  /**
+   * Write task/tool artifacts using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_bmad-help.md
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Task/tool artifacts with relativePath
+   * @returns {number} Count of commands written
+   */
+  async writeDashArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'task' || artifact.type === 'tool') {
+        const commandContent = this.generateCommandContent(artifact, artifact.type);
+        // Use underscore format: bmad_module_name.md
+        const flatName = toDashPath(artifact.relativePath);
+        const commandPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(commandPath));
+        await fs.writeFile(commandPath, commandContent);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+}
+
+module.exports = { TaskToolCommandGenerator };