bmad-fh 6.0.0-alpha.23

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

@@ -0,0 +1,12 @@
+description = "Executes the {{taskName}} task from the BMad Method."
+prompt = """
+Execute the following BMad Method task workflow:
+
+PRE-FLIGHT CHECKLIST:
+1.  [ ] IMMEDIATE ACTION: Load and parse @{_bmad}/{{module}}/config.yaml.
+2.  [ ] IMMEDIATE ACTION: Read and load the task definition at @{_bmad}/{{module}}/tasks/{{filename}}.
+
+Follow all instructions and complete the task as defined.
+
+TASK DEFINITION: @{_bmad}/{{module}}/tasks/{{filename}}
+"""

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

@@ -0,0 +1,30 @@
+---
+description: '{{description}}'
+---
+
+IT IS CRITICAL THAT YOU FOLLOW THESE STEPS - while staying in character as the current agent persona you may have loaded:
+
+<steps CRITICAL="TRUE">
+1. Always LOAD the FULL @_bmad/core/tasks/workflow.xml
+2. READ its entire contents - this is the CORE OS for EXECUTING the specific workflow-config @{{workflow_path}}
+3. Pass the yaml path {{workflow_path}} as 'workflow-config' parameter to the workflow.xml instructions
+4. Follow workflow.xml instructions EXACTLY as written to process and follow the specific workflow config and its instructions
+5. Save outputs after EACH section when generating any documents from templates
+</steps>
+
+<scope-resolution>
+## Multi-Scope Support
+
+This workflow supports multi-scope parallel artifacts. Scope resolution order:
+
+1. **--scope flag**: If provided (e.g., `/{{name}} --scope auth`), use that scope
+2. **Session context**: Check for `.bmad-scope` file in project root
+3. **Environment variable**: Check `BMAD_SCOPE` env var
+4. **Prompt user**: If workflow requires scope and none found, prompt to select/create
+
+When a scope is active:
+- Artifacts are isolated to `_bmad-output/{scope}/`
+- Cross-scope reads are allowed, writes are blocked
+- Use `bmad scope sync-up` to promote artifacts to shared layer
+- Check for pending dependency updates at workflow start
+</scope-resolution>

package/tools/cli/installers/lib/ide/templates/workflow-commander.md

@@ -0,0 +1,45 @@
+---
+description: '{{description}}'
+---
+
+IT IS CRITICAL THAT YOU FOLLOW THESE STEPS IN ORDER:
+
+<scope-resolution CRITICAL="true">
+## Step 0: Resolve Scope Context BEFORE Workflow Execution
+
+The workflow file will instruct you to load config.yaml. BEFORE following those instructions:
+
+### 0a. Check for Active Scope
+1. Check for `.bmad-scope` file in {project-root}
+2. If exists, read the `active_scope` value and store as {scope}
+3. If `.bmad-scope` does not exist, skip to Step 1 (backward compatible, no scope)
+
+### 0b. Override Config Paths (CRITICAL - if scope is set)
+After loading config.yaml but BEFORE using any paths, you MUST override these variables:
+
+```
+{scope_path} = {output_folder}/{scope}
+{planning_artifacts} = {scope_path}/planning-artifacts
+{implementation_artifacts} = {scope_path}/implementation-artifacts
+{scope_tests} = {scope_path}/tests
+```
+
+**Example:** If config.yaml has `output_folder: "_bmad-output"` and scope is "auth":
+- {scope_path} = `_bmad-output/auth`
+- {planning_artifacts} = `_bmad-output/auth/planning-artifacts`
+- {implementation_artifacts} = `_bmad-output/auth/implementation-artifacts`
+
+**WARNING:** Config.yaml contains pre-resolved static paths. You MUST override them with the scope-aware paths above. DO NOT use the config.yaml values directly for these variables when a scope is active.
+
+### 0c. Load Scope Context
+If scope is set:
+- Load global context: `{output_folder}/_shared/project-context.md`
+- Load scope context if exists: `{scope_path}/project-context.md`
+- Merge: scope-specific content extends/overrides global
+</scope-resolution>
+
+## Step 1: Execute Workflow
+
+NOW: LOAD the FULL @{{workflow_path}}, READ its entire contents and follow its directions exactly!
+
+When the workflow instructs you to use `{planning_artifacts}` or `{implementation_artifacts}`, use YOUR OVERRIDDEN VALUES from Step 0b, not the static config.yaml values.

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

@@ -0,0 +1,313 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * Trae IDE setup handler
+ */
+class TraeSetup extends BaseIdeSetup {
+  constructor() {
+    super('trae', 'Trae');
+    this.configDir = '.trae';
+    this.rulesDir = 'rules';
+  }
+
+  /**
+   * Setup Trae 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 .trae/rules directory
+    const traeDir = path.join(projectDir, this.configDir);
+    const rulesDir = path.join(traeDir, this.rulesDir);
+
+    await this.ensureDir(rulesDir);
+
+    // Clean up any existing BMAD files before reinstalling
+    await this.cleanup(projectDir);
+
+    // Generate agent launchers
+    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
+
+    // Get tasks, tools, and workflows (standalone only)
+    const tasks = await this.getTasks(bmadDir, true);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Process agents as rules with bmad- prefix
+    let agentCount = 0;
+    for (const artifact of agentArtifacts) {
+      const processedContent = await this.createAgentRule(artifact, bmadDir, projectDir);
+
+      // Use bmad- prefix: bmad-agent-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-agent-${artifact.module}-${artifact.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      agentCount++;
+    }
+
+    // Process tasks as rules with bmad- prefix
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const processedContent = this.createTaskRule(task, content);
+
+      // Use bmad- prefix: bmad-task-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-task-${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      taskCount++;
+    }
+
+    // Process tools as rules with bmad- prefix
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readFile(tool.path);
+      const processedContent = this.createToolRule(tool, content);
+
+      // Use bmad- prefix: bmad-tool-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-tool-${tool.module}-${tool.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      toolCount++;
+    }
+
+    // Process workflows as rules with bmad- prefix
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readFile(workflow.path);
+      const processedContent = this.createWorkflowRule(workflow, content);
+
+      // Use bmad- prefix: bmad-workflow-{module}-{name}.md
+      const targetPath = path.join(rulesDir, `bmad-workflow-${workflow.module}-${workflow.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      workflowCount++;
+    }
+
+    const totalRules = agentCount + taskCount + toolCount + workflowCount;
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agent rules created`));
+    console.log(chalk.dim(`  - ${taskCount} task rules created`));
+    console.log(chalk.dim(`  - ${toolCount} tool rules created`));
+    console.log(chalk.dim(`  - ${workflowCount} workflow rules created`));
+    console.log(chalk.dim(`  - Total: ${totalRules} rules`));
+    console.log(chalk.dim(`  - Rules directory: ${path.relative(projectDir, rulesDir)}`));
+    console.log(chalk.dim(`  - Agents can be activated with @{agent-name}`));
+
+    return {
+      success: true,
+      rules: totalRules,
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Create rule content for an agent
+   */
+  async createAgentRule(artifact, bmadDir, projectDir) {
+    // Strip frontmatter from launcher
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
+
+    // Extract metadata from launcher content
+    const titleMatch = artifact.content.match(/description:\s*"([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
+
+    // Calculate relative path for reference
+    const relativePath = path.relative(projectDir, artifact.sourcePath).replaceAll('\\', '/');
+
+    let ruleContent = `# ${title} Agent Rule
+
+This rule is triggered when the user types \`@${artifact.name}\` and activates the ${title} agent persona.
+
+## Agent Activation
+
+${contentWithoutFrontmatter}
+
+## File Reference
+
+The full agent definition is located at: \`${relativePath}\`
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Create rule content for a task
+   */
+  createTaskRule(task, content) {
+    // Extract task name from content
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    let ruleContent = `# ${taskName} Task Rule
+
+This rule defines the ${taskName} task workflow.
+
+## Task Definition
+
+When this task is triggered, execute the following workflow:
+
+${content}
+
+## Usage
+
+Reference this task with \`@task-${task.name}\` to execute the defined workflow.
+
+## Module
+
+Part of the BMAD ${task.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Create rule content for a tool
+   */
+  createToolRule(tool, content) {
+    // Extract tool name from content
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const toolName = nameMatch ? nameMatch[1] : this.formatTitle(tool.name);
+
+    let ruleContent = `# ${toolName} Tool Rule
+
+This rule defines the ${toolName} tool.
+
+## Tool Definition
+
+When this tool is triggered, execute the following:
+
+${content}
+
+## Usage
+
+Reference this tool with \`@tool-${tool.name}\` to execute it.
+
+## Module
+
+Part of the BMAD ${tool.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Create rule content for a workflow
+   */
+  createWorkflowRule(workflow, content) {
+    let ruleContent = `# ${workflow.name} Workflow Rule
+
+This rule defines the ${workflow.name} workflow.
+
+## Workflow Description
+
+${workflow.description || 'No description provided'}
+
+## Workflow Definition
+
+${content}
+
+## Usage
+
+Reference this workflow with \`@workflow-${workflow.name}\` to execute the guided workflow.
+
+## Module
+
+Part of the BMAD ${workflow.module.toUpperCase()} module.
+`;
+
+    return ruleContent;
+  }
+
+  /**
+   * Format agent/task name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Trae configuration - surgically remove only BMAD files
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const rulesPath = path.join(projectDir, this.configDir, this.rulesDir);
+
+    if (await fs.pathExists(rulesPath)) {
+      // Only remove files that start with bmad- prefix
+      const files = await fs.readdir(rulesPath);
+      let removed = 0;
+
+      for (const file of files) {
+        if (file.startsWith('bmad-') && file.endsWith('.md')) {
+          await fs.remove(path.join(rulesPath, file));
+          removed++;
+        }
+      }
+
+      if (removed > 0) {
+        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD rules`));
+      }
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for Trae
+   * @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 traeDir = path.join(projectDir, this.configDir);
+    const rulesDir = path.join(traeDir, this.rulesDir);
+
+    // Create .trae/rules directory if it doesn't exist
+    await fs.ensureDir(rulesDir);
+
+    // Create custom agent launcher
+    const launcherContent = `# ${agentName} Custom Agent
+
+**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
+
+This is a launcher for the custom BMAD agent "${agentName}".
+
+## Usage
+1. First run: \`${agentPath}\` to load the complete agent
+2. Then use this rule to activate ${agentName}
+
+The agent will follow the persona and instructions from the main agent file.
+
+---
+
+*Generated by BMAD Method*`;
+
+    const fileName = `bmad-agent-custom-${agentName.toLowerCase()}.md`;
+    const launcherPath = path.join(rulesDir, fileName);
+
+    // Write the launcher file
+    await fs.writeFile(launcherPath, launcherContent, 'utf8');
+
+    return {
+      ide: 'trae',
+      path: path.relative(projectDir, launcherPath),
+      command: agentName,
+      type: 'custom-agent-launcher',
+    };
+  }
+}
+
+module.exports = { TraeSetup };

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

@@ -0,0 +1,258 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * Windsurf IDE setup handler
+ */
+class WindsurfSetup extends BaseIdeSetup {
+  constructor() {
+    super('windsurf', 'Windsurf', true); // preferred IDE
+    this.configDir = '.windsurf';
+    this.workflowsDir = 'workflows';
+  }
+
+  /**
+   * Setup Windsurf 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 .windsurf/workflows/bmad directory structure
+    const windsurfDir = path.join(projectDir, this.configDir);
+    const workflowsDir = path.join(windsurfDir, this.workflowsDir);
+    const bmadWorkflowsDir = path.join(workflowsDir, 'bmad');
+
+    await this.ensureDir(bmadWorkflowsDir);
+
+    // Clean up any existing BMAD workflows before reinstalling
+    await this.cleanup(projectDir);
+
+    // Generate agent launchers
+    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
+
+    // Convert artifacts to agent format for module organization
+    const agents = agentArtifacts.map((a) => ({ module: a.module, name: a.name }));
+
+    // Get tasks, tools, and workflows (standalone only)
+    const tasks = await this.getTasks(bmadDir, true);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Create directories for each module under bmad/
+    const modules = new Set();
+    for (const item of [...agents, ...tasks, ...tools, ...workflows]) modules.add(item.module);
+
+    for (const module of modules) {
+      await this.ensureDir(path.join(bmadWorkflowsDir, module));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'agents'));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'tasks'));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'tools'));
+      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'workflows'));
+    }
+
+    // Process agent launchers as workflows with organized structure
+    let agentCount = 0;
+    for (const artifact of agentArtifacts) {
+      const processedContent = this.createWorkflowContent({ module: artifact.module, name: artifact.name }, artifact.content);
+
+      // Organized path: bmad/module/agents/agent-name.md
+      const targetPath = path.join(bmadWorkflowsDir, artifact.module, 'agents', `${artifact.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      agentCount++;
+    }
+
+    // Process tasks as workflows with organized structure
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readFile(task.path);
+      const processedContent = this.createTaskWorkflowContent(task, content);
+
+      // Organized path: bmad/module/tasks/task-name.md
+      const targetPath = path.join(bmadWorkflowsDir, task.module, 'tasks', `${task.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      taskCount++;
+    }
+
+    // Process tools as workflows with organized structure
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readFile(tool.path);
+      const processedContent = this.createToolWorkflowContent(tool, content);
+
+      // Organized path: bmad/module/tools/tool-name.md
+      const targetPath = path.join(bmadWorkflowsDir, tool.module, 'tools', `${tool.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      toolCount++;
+    }
+
+    // Process workflows with organized structure
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readFile(workflow.path);
+      const processedContent = this.createWorkflowWorkflowContent(workflow, content);
+
+      // Organized path: bmad/module/workflows/workflow-name.md
+      const targetPath = path.join(bmadWorkflowsDir, workflow.module, 'workflows', `${workflow.name}.md`);
+      await this.writeFile(targetPath, processedContent);
+      workflowCount++;
+    }
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents installed`));
+    console.log(chalk.dim(`  - ${taskCount} tasks installed`));
+    console.log(chalk.dim(`  - ${toolCount} tools installed`));
+    console.log(chalk.dim(`  - ${workflowCount} workflows installed`));
+    console.log(chalk.dim(`  - Organized in modules: ${[...modules].join(', ')}`));
+    console.log(chalk.dim(`  - Workflows directory: ${path.relative(projectDir, workflowsDir)}`));
+
+    // Provide additional configuration hints
+    if (options.showHints !== false) {
+      console.log(chalk.dim('\n  Windsurf workflow settings:'));
+      console.log(chalk.dim('  - auto_execution_mode: 3 (recommended for agents)'));
+      console.log(chalk.dim('  - auto_execution_mode: 2 (recommended for tasks/tools)'));
+      console.log(chalk.dim('  - auto_execution_mode: 1 (recommended for workflows)'));
+      console.log(chalk.dim('  - Workflows can be triggered via the Windsurf menu'));
+    }
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Create workflow content for an agent
+   */
+  createWorkflowContent(agent, content) {
+    // Strip existing frontmatter from launcher
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = content.replace(frontmatterRegex, '');
+
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: ${agent.name}
+auto_execution_mode: 3
+---
+
+${contentWithoutFrontmatter}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Create workflow content for a task
+   */
+  createTaskWorkflowContent(task, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: task-${task.name}
+auto_execution_mode: 2
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Create workflow content for a tool
+   */
+  createToolWorkflowContent(tool, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: tool-${tool.name}
+auto_execution_mode: 2
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Create workflow content for a workflow
+   */
+  createWorkflowWorkflowContent(workflow, content) {
+    // Create simple Windsurf frontmatter matching original format
+    let workflowContent = `---
+description: ${workflow.name}
+auto_execution_mode: 1
+---
+
+${content}`;
+
+    return workflowContent;
+  }
+
+  /**
+   * Cleanup Windsurf configuration - surgically remove only BMAD files
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const bmadPath = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad');
+
+    if (await fs.pathExists(bmadPath)) {
+      // Remove the entire bmad folder - this is our territory
+      await fs.remove(bmadPath);
+      console.log(chalk.dim(`  Cleaned up existing BMAD workflows`));
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for Windsurf
+   * @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|null} Info about created command
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    const fs = require('fs-extra');
+    const customAgentsDir = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad', 'custom', 'agents');
+
+    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
+      return null; // IDE not configured for this project
+    }
+
+    await this.ensureDir(customAgentsDir);
+
+    const launcherContent = `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 @${agentPath}
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. FOLLOW every step in the <activation> section precisely
+4. DISPLAY the welcome/greeting as instructed
+5. PRESENT the numbered menu
+6. WAIT for user input before proceeding
+</agent-activation>
+`;
+
+    // Windsurf uses workflow format with frontmatter
+    const workflowContent = `---
+description: ${metadata.title || agentName}
+auto_execution_mode: 3
+---
+
+${launcherContent}`;
+
+    const launcherPath = path.join(customAgentsDir, `${agentName}.md`);
+    await fs.writeFile(launcherPath, workflowContent);
+
+    return {
+      path: launcherPath,
+      command: `bmad/custom/agents/${agentName}`,
+    };
+  }
+}
+
+module.exports = { WindsurfSetup };