bmad-fh 6.0.0-alpha.23

package/tools/cli/installers/lib/ide/shared/bmad-artifacts.js

@@ -0,0 +1,158 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+
+/**
+ * Helpers for gathering BMAD agents/tasks from the installed tree.
+ * Shared by installers that need Claude-style exports.
+ */
+async function getAgentsFromBmad(bmadDir, selectedModules = []) {
+  const agents = [];
+
+  // Get core agents
+  if (await fs.pathExists(path.join(bmadDir, 'core', 'agents'))) {
+    const coreAgents = await getAgentsFromDir(path.join(bmadDir, 'core', 'agents'), 'core');
+    agents.push(...coreAgents);
+  }
+
+  // Get module agents
+  for (const moduleName of selectedModules) {
+    const agentsPath = path.join(bmadDir, moduleName, 'agents');
+
+    if (await fs.pathExists(agentsPath)) {
+      const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
+      agents.push(...moduleAgents);
+    }
+  }
+
+  // Get standalone agents from bmad/agents/ directory
+  const standaloneAgentsDir = path.join(bmadDir, 'agents');
+  if (await fs.pathExists(standaloneAgentsDir)) {
+    const agentDirs = await fs.readdir(standaloneAgentsDir, { withFileTypes: true });
+
+    for (const agentDir of agentDirs) {
+      if (!agentDir.isDirectory()) continue;
+
+      const agentDirPath = path.join(standaloneAgentsDir, agentDir.name);
+      const agentFiles = await fs.readdir(agentDirPath);
+
+      for (const file of agentFiles) {
+        if (!file.endsWith('.md')) continue;
+        if (file.includes('.customize.')) continue;
+
+        const filePath = path.join(agentDirPath, file);
+        const content = await fs.readFile(filePath, 'utf8');
+
+        if (content.includes('localskip="true"')) continue;
+
+        agents.push({
+          path: filePath,
+          name: file.replace('.md', ''),
+          module: 'standalone', // Mark as standalone agent
+        });
+      }
+    }
+  }
+
+  return agents;
+}
+
+async function getTasksFromBmad(bmadDir, selectedModules = []) {
+  const tasks = [];
+
+  if (await fs.pathExists(path.join(bmadDir, 'core', 'tasks'))) {
+    const coreTasks = await getTasksFromDir(path.join(bmadDir, 'core', 'tasks'), 'core');
+    tasks.push(...coreTasks);
+  }
+
+  for (const moduleName of selectedModules) {
+    const tasksPath = path.join(bmadDir, moduleName, 'tasks');
+
+    if (await fs.pathExists(tasksPath)) {
+      const moduleTasks = await getTasksFromDir(tasksPath, moduleName);
+      tasks.push(...moduleTasks);
+    }
+  }
+
+  return tasks;
+}
+
+async function getAgentsFromDir(dirPath, moduleName, relativePath = '') {
+  const agents = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return agents;
+  }
+
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      // Recurse into subdirectories
+      const subDirAgents = await getAgentsFromDir(fullPath, moduleName, newRelativePath);
+      agents.push(...subDirAgents);
+    } else if (entry.name.endsWith('.md')) {
+      // Skip README files and other non-agent files
+      if (entry.name.toLowerCase() === 'readme.md' || entry.name.toLowerCase().startsWith('readme-')) {
+        continue;
+      }
+
+      if (entry.name.includes('.customize.')) {
+        continue;
+      }
+
+      const content = await fs.readFile(fullPath, 'utf8');
+
+      if (content.includes('localskip="true"')) {
+        continue;
+      }
+
+      // Only include files that have agent-specific content (compiled agents have <agent> tag)
+      if (!content.includes('<agent')) {
+        continue;
+      }
+
+      agents.push({
+        path: fullPath,
+        name: entry.name.replace('.md', ''),
+        module: moduleName,
+        relativePath: newRelativePath, // Keep the .md extension for the full path
+      });
+    }
+  }
+
+  return agents;
+}
+
+async function getTasksFromDir(dirPath, moduleName) {
+  const tasks = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return tasks;
+  }
+
+  const files = await fs.readdir(dirPath);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) {
+      continue;
+    }
+
+    tasks.push({
+      path: path.join(dirPath, file),
+      name: file.replace('.md', ''),
+      module: moduleName,
+    });
+  }
+
+  return tasks;
+}
+
+module.exports = {
+  getAgentsFromBmad,
+  getTasksFromBmad,
+  getAgentsFromDir,
+  getTasksFromDir,
+};

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/task-tool-command-generator.js

@@ -0,0 +1,119 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const chalk = require('chalk');
+
+/**
+ * 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,
+    });
+  }
+}
+
+module.exports = { TaskToolCommandGenerator };

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

@@ -0,0 +1,242 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const chalk = require('chalk');
+
+/**
+ * Generates command files for each workflow in the manifest
+ */
+class WorkflowCommandGenerator {
+  constructor(bmadFolderName = 'bmad') {
+    this.templatePath = path.join(__dirname, '../templates/workflow-command-template.md');
+    this.bmadFolderName = bmadFolderName;
+  }
+
+  /**
+   * Generate workflow commands from the manifest CSV
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   */
+  async generateWorkflowCommands(projectDir, bmadDir) {
+    const workflows = await this.loadWorkflowManifest(bmadDir);
+
+    if (!workflows) {
+      console.log(chalk.yellow('Workflow manifest not found. Skipping command generation.'));
+      return { generated: 0 };
+    }
+
+    // ALL workflows now generate commands - no standalone filtering
+    const allWorkflows = workflows;
+
+    // Base commands directory
+    const baseCommandsDir = path.join(projectDir, '.claude', 'commands', 'bmad');
+
+    let generatedCount = 0;
+
+    // Generate a command file for each workflow, organized by module
+    for (const workflow of allWorkflows) {
+      const moduleWorkflowsDir = path.join(baseCommandsDir, workflow.module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+
+      const commandContent = await this.generateCommandContent(workflow, bmadDir);
+      const commandPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Also create a workflow launcher README in each module
+    const groupedWorkflows = this.groupWorkflowsByModule(allWorkflows);
+    await this.createModuleWorkflowLaunchers(baseCommandsDir, groupedWorkflows);
+
+    return { generated: generatedCount };
+  }
+
+  async collectWorkflowArtifacts(bmadDir) {
+    const workflows = await this.loadWorkflowManifest(bmadDir);
+
+    if (!workflows) {
+      return { artifacts: [], counts: { commands: 0, launchers: 0 } };
+    }
+
+    // ALL workflows now generate commands - no standalone filtering
+    const allWorkflows = workflows;
+
+    const artifacts = [];
+
+    for (const workflow of allWorkflows) {
+      const commandContent = await this.generateCommandContent(workflow, bmadDir);
+      artifacts.push({
+        type: 'workflow-command',
+        module: workflow.module,
+        relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
+        content: commandContent,
+        sourcePath: workflow.path,
+      });
+    }
+
+    const groupedWorkflows = this.groupWorkflowsByModule(allWorkflows);
+    for (const [module, launcherContent] of Object.entries(this.buildModuleWorkflowLaunchers(groupedWorkflows))) {
+      artifacts.push({
+        type: 'workflow-launcher',
+        module,
+        relativePath: path.join(module, 'workflows', 'README.md'),
+        content: launcherContent,
+        sourcePath: null,
+      });
+    }
+
+    return {
+      artifacts,
+      counts: {
+        commands: allWorkflows.length,
+        launchers: Object.keys(groupedWorkflows).length,
+      },
+    };
+  }
+
+  /**
+   * Generate command content for a workflow
+   */
+  async generateCommandContent(workflow, bmadDir) {
+    // Determine template based on workflow file type
+    const isMarkdownWorkflow = workflow.path.endsWith('workflow.md');
+    const templateName = isMarkdownWorkflow ? 'workflow-commander.md' : 'workflow-command-template.md';
+    const templatePath = path.join(path.dirname(this.templatePath), templateName);
+
+    // Load the appropriate template
+    const template = await fs.readFile(templatePath, 'utf8');
+
+    // Convert source path to installed path
+    // From: /Users/.../src/bmm/workflows/.../workflow.yaml
+    // To: {project-root}/_bmad/bmm/workflows/.../workflow.yaml
+    let workflowPath = workflow.path;
+
+    // Extract the relative path from source
+    if (workflowPath.includes('/src/bmm/')) {
+      // bmm is directly under src/
+      const match = workflowPath.match(/\/src\/bmm\/(.+)/);
+      if (match) {
+        workflowPath = `${this.bmadFolderName}/bmm/${match[1]}`;
+      }
+    } else if (workflowPath.includes('/src/core/')) {
+      const match = workflowPath.match(/\/src\/core\/(.+)/);
+      if (match) {
+        workflowPath = `${this.bmadFolderName}/core/${match[1]}`;
+      }
+    }
+
+    // Replace template variables
+    return template
+      .replaceAll('{{name}}', workflow.name)
+      .replaceAll('{{module}}', workflow.module)
+      .replaceAll('{{description}}', workflow.description)
+      .replaceAll('{{workflow_path}}', workflowPath)
+      .replaceAll('_bmad', this.bmadFolderName)
+      .replaceAll('_bmad', '_bmad');
+  }
+
+  /**
+   * Create workflow launcher files for each module
+   */
+  async createModuleWorkflowLaunchers(baseCommandsDir, workflowsByModule) {
+    for (const [module, moduleWorkflows] of Object.entries(workflowsByModule)) {
+      const content = this.buildLauncherContent(module, moduleWorkflows);
+      const moduleWorkflowsDir = path.join(baseCommandsDir, module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+      const launcherPath = path.join(moduleWorkflowsDir, 'README.md');
+      await fs.writeFile(launcherPath, content);
+    }
+  }
+
+  groupWorkflowsByModule(workflows) {
+    const workflowsByModule = {};
+
+    for (const workflow of workflows) {
+      if (!workflowsByModule[workflow.module]) {
+        workflowsByModule[workflow.module] = [];
+      }
+
+      workflowsByModule[workflow.module].push({
+        ...workflow,
+        displayPath: this.transformWorkflowPath(workflow.path),
+      });
+    }
+
+    return workflowsByModule;
+  }
+
+  buildModuleWorkflowLaunchers(groupedWorkflows) {
+    const launchers = {};
+
+    for (const [module, moduleWorkflows] of Object.entries(groupedWorkflows)) {
+      launchers[module] = this.buildLauncherContent(module, moduleWorkflows);
+    }
+
+    return launchers;
+  }
+
+  buildLauncherContent(module, moduleWorkflows) {
+    let content = `# ${module.toUpperCase()} Workflows
+
+## Available Workflows in ${module}
+
+`;
+
+    for (const workflow of moduleWorkflows) {
+      content += `**${workflow.name}**\n`;
+      content += `- Path: \`${workflow.displayPath}\`\n`;
+      content += `- ${workflow.description}\n\n`;
+    }
+
+    content += `
+## Execution
+
+When running any workflow:
+1. LOAD {project-root}/${this.bmadFolderName}/core/tasks/workflow.xml
+2. Pass the workflow path as 'workflow-config' parameter
+3. Follow workflow.xml instructions EXACTLY
+4. Save outputs after EACH section
+
+## Modes
+- Normal: Full interaction
+- #yolo: Skip optional steps
+`;
+
+    return content;
+  }
+
+  transformWorkflowPath(workflowPath) {
+    let transformed = workflowPath;
+
+    if (workflowPath.includes('/src/bmm/')) {
+      const match = workflowPath.match(/\/src\/bmm\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/${this.bmadFolderName}/bmm/${match[1]}`;
+      } else if (workflowPath.includes('/src/core/')) {
+        const match = workflowPath.match(/\/src\/core\/(.+)/);
+        if (match) {
+          transformed = `{project-root}/${this.bmadFolderName}/core/${match[1]}`;
+        }
+      }
+
+      return transformed;
+    }
+  }
+
+  async loadWorkflowManifest(bmadDir) {
+    const manifestPath = path.join(bmadDir, '_config', 'workflow-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,
+    });
+  }
+}
+
+module.exports = { WorkflowCommandGenerator };

package/tools/cli/installers/lib/ide/templates/agent-command-template.md

@@ -0,0 +1,29 @@
+---
+name: '{{name}}'
+description: '{{description}}'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @_bmad/{{module}}/agents/{{path}}
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. Execute ALL activation steps exactly as written in the agent file
+4. Follow the agent's persona and menu system precisely
+5. Stay in character throughout the session
+</agent-activation>
+
+<scope-awareness>
+## Multi-Scope Context
+
+When activated, check for scope context:
+
+1. **Session scope**: Look for `.bmad-scope` file in project root
+2. **Load context**: If scope is active, load both:
+   - Global context: `_bmad-output/_shared/project-context.md`
+   - Scope context: `_bmad-output/{scope}/project-context.md` (if exists)
+3. **Merge contexts**: Scope-specific context extends/overrides global
+4. **Menu items with `scope_required: true`**: Prompt for scope before executing
+
+For menu items that produce artifacts, ensure they go to the active scope's directory.
+</scope-awareness>

package/tools/cli/installers/lib/ide/templates/gemini-agent-command.toml

@@ -0,0 +1,14 @@
+description = "Activates the {{title}} agent from the BMad Method."
+prompt = """
+CRITICAL: You are now the BMad '{{title}}' agent.
+
+PRE-FLIGHT CHECKLIST:
+1.  [ ] IMMEDIATE ACTION: Load and parse @{_bmad}/{{module}}/config.yaml - store ALL config values in memory for use throughout the session.
+2.  [ ] IMMEDIATE ACTION: Read and internalize the full agent definition at @{_bmad}/{{module}}/agents/{{name}}.md.
+3.  [ ] CONFIRM: The user's name from config is {user_name}.
+
+Only after all checks are complete, greet the user by name and display the menu.
+Acknowledge this checklist is complete in your first response.
+
+AGENT DEFINITION: @{_bmad}/{{module}}/agents/{{name}}.md
+"""