bmad-method 5.1.3 → 6.0.0-Beta.0

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 };

package/tools/cli/installers/lib/message-loader.js

@@ -0,0 +1,85 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('yaml');
+const chalk = require('chalk');
+
+/**
+ * Load and display installer messages from messages.yaml
+ */
+class MessageLoader {
+  constructor() {}
+
+  /**
+   * Load messages from the YAML file
+   * @returns {Object|null} Messages object or null if not found
+   */
+  load() {
+    if (this.messages) {
+      return this.messages;
+    }
+
+    const messagesPath = path.join(__dirname, '..', 'install-messages.yaml');
+
+    try {
+      const content = fs.readFileSync(messagesPath, 'utf8');
+      this.messages = yaml.parse(content);
+      return this.messages;
+    } catch {
+      // File doesn't exist or is invalid - return null
+      return null;
+    }
+  }
+
+  /**
+   * Get the start message for display
+   * @returns {string|null} Start message or null
+   */
+  getStartMessage() {
+    const messages = this.load();
+    return messages?.startMessage || null;
+  }
+
+  /**
+   * Get the end message for display
+   * @returns {string|null} End message or null
+   */
+  getEndMessage() {
+    const messages = this.load();
+    return messages?.endMessage || null;
+  }
+
+  /**
+   * Display the start message (after logo, before prompts)
+   */
+  displayStartMessage() {
+    const message = this.getStartMessage();
+    if (message) {
+      console.log(chalk.cyan(message));
+      console.log();
+    }
+  }
+
+  /**
+   * Display the end message (after installation completes)
+   */
+  displayEndMessage() {
+    const message = this.getEndMessage();
+    if (message) {
+      console.log();
+      console.log(chalk.cyan(message));
+    }
+  }
+
+  /**
+   * Check if messages exist for the current version
+   * @param {string} currentVersion - Current package version
+   * @returns {boolean} True if messages match current version
+   */
+  isCurrent(currentVersion) {
+    const messages = this.load();
+    return messages && messages.version === currentVersion;
+  }
+  messages = null;
+}
+
+module.exports = { MessageLoader };

package/tools/cli/installers/lib/modules/external-manager.js

@@ -0,0 +1,135 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('yaml');
+
+/**
+ * Manages external official modules defined in external-official-modules.yaml
+ * These are modules hosted in external repositories that can be installed
+ *
+ * @class ExternalModuleManager
+ */
+class ExternalModuleManager {
+  constructor() {
+    this.externalModulesConfigPath = path.join(__dirname, '../../../external-official-modules.yaml');
+    this.cachedModules = null;
+  }
+
+  /**
+   * Load and parse the external-official-modules.yaml file
+   * @returns {Object} Parsed YAML content with modules object
+   */
+  async loadExternalModulesConfig() {
+    if (this.cachedModules) {
+      return this.cachedModules;
+    }
+
+    try {
+      const content = await fs.readFile(this.externalModulesConfigPath, 'utf8');
+      const config = yaml.parse(content);
+      this.cachedModules = config;
+      return config;
+    } catch (error) {
+      console.warn(`Failed to load external modules config: ${error.message}`);
+      return { modules: {} };
+    }
+  }
+
+  /**
+   * Get list of available external modules
+   * @returns {Array<Object>} Array of module info objects
+   */
+  async listAvailable() {
+    const config = await this.loadExternalModulesConfig();
+    const modules = [];
+
+    for (const [key, moduleConfig] of Object.entries(config.modules || {})) {
+      modules.push({
+        key,
+        url: moduleConfig.url,
+        moduleDefinition: moduleConfig['module-definition'],
+        code: moduleConfig.code,
+        name: moduleConfig.name,
+        header: moduleConfig.header,
+        subheader: moduleConfig.subheader,
+        description: moduleConfig.description || '',
+        defaultSelected: moduleConfig.defaultSelected === true,
+        type: moduleConfig.type || 'community', // bmad-org or community
+        npmPackage: moduleConfig.npmPackage || null, // Include npm package name
+        isExternal: true,
+      });
+    }
+
+    return modules;
+  }
+
+  /**
+   * Get module info by code
+   * @param {string} code - The module code (e.g., 'cis')
+   * @returns {Object|null} Module info or null if not found
+   */
+  async getModuleByCode(code) {
+    const modules = await this.listAvailable();
+    return modules.find((m) => m.code === code) || null;
+  }
+
+  /**
+   * Get module info by key
+   * @param {string} key - The module key (e.g., 'bmad-creative-intelligence-suite')
+   * @returns {Object|null} Module info or null if not found
+   */
+  async getModuleByKey(key) {
+    const config = await this.loadExternalModulesConfig();
+    const moduleConfig = config.modules?.[key];
+
+    if (!moduleConfig) {
+      return null;
+    }
+
+    return {
+      key,
+      url: moduleConfig.url,
+      moduleDefinition: moduleConfig['module-definition'],
+      code: moduleConfig.code,
+      name: moduleConfig.name,
+      header: moduleConfig.header,
+      subheader: moduleConfig.subheader,
+      description: moduleConfig.description || '',
+      defaultSelected: moduleConfig.defaultSelected === true,
+      type: moduleConfig.type || 'community', // bmad-org or community
+      npmPackage: moduleConfig.npmPackage || null, // Include npm package name
+      isExternal: true,
+    };
+  }
+
+  /**
+   * Check if a module code exists in external modules
+   * @param {string} code - The module code to check
+   * @returns {boolean} True if the module exists
+   */
+  async hasModule(code) {
+    const module = await this.getModuleByCode(code);
+    return module !== null;
+  }
+
+  /**
+   * Get the URL for a module by code
+   * @param {string} code - The module code
+   * @returns {string|null} The URL or null if not found
+   */
+  async getModuleUrl(code) {
+    const module = await this.getModuleByCode(code);
+    return module ? module.url : null;
+  }
+
+  /**
+   * Get the module definition path for a module by code
+   * @param {string} code - The module code
+   * @returns {string|null} The module definition path or null if not found
+   */
+  async getModuleDefinition(code) {
+    const module = await this.getModuleByCode(code);
+    return module ? module.moduleDefinition : null;
+  }
+}
+
+module.exports = { ExternalModuleManager };