bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -1,16 +1,18 @@
 const path = require('node:path');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
+const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');
 
 /**
  * Qwen Code setup handler
- * Creates concatenated QWEN.md file in .qwen/bmad-method/ (similar to Gemini)
+ * Creates TOML command files in .qwen/commands/BMad/
  */
 class QwenSetup extends BaseIdeSetup {
   constructor() {
     super('qwen', 'Qwen Code');
     this.configDir = '.qwen';
-    this.bmadDir = 'bmad-method';
+    this.commandsDir = 'commands';
+    this.bmadDir = 'bmad';
   }
 
   /**
@@ -22,54 +24,114 @@ class QwenSetup extends BaseIdeSetup {
   async setup(projectDir, bmadDir, options = {}) {
     console.log(chalk.cyan(`Setting up ${this.name}...`));
 
-    // Create .qwen/bmad-method directory
+    // Create .qwen/commands/BMad directory structure
     const qwenDir = path.join(projectDir, this.configDir);
-    const bmadMethodDir = path.join(qwenDir, this.bmadDir);
-    await this.ensureDir(bmadMethodDir);
+    const commandsDir = path.join(qwenDir, this.commandsDir);
+    const bmadCommandsDir = path.join(commandsDir, this.bmadDir);
+
+    await this.ensureDir(bmadCommandsDir);
 
     // Update existing settings.json if present
     await this.updateSettings(qwenDir);
 
-    // Clean up old agents directory if exists
-    await this.cleanupOldAgents(qwenDir);
+    // Clean up old configuration if exists
+    await this.cleanupOldConfig(qwenDir);
+
+    // Get agents, tasks, tools, and workflows (standalone only for tools/workflows)
+    const agents = await getAgentsFromBmad(bmadDir, options.selectedModules || []);
+    const tasks = await getTasksFromBmad(bmadDir, options.selectedModules || []);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Create directories for each module (including standalone)
+    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(bmadCommandsDir, module));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'agents'));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'tasks'));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'tools'));
+      await this.ensureDir(path.join(bmadCommandsDir, module, 'workflows'));
+    }
 
-    // Get agents
-    const agents = await this.getAgents(bmadDir);
+    // Create TOML files for each agent
+    let agentCount = 0;
+    for (const agent of agents) {
+      const content = await this.readAndProcess(agent.path, {
+        module: agent.module,
+        name: agent.name,
+      });
 
-    // Create concatenated content for all agents
-    let concatenatedContent = `# BMAD Method - Qwen Code Configuration
+      const targetPath = path.join(bmadCommandsDir, agent.module, 'agents', `${agent.name}.toml`);
 
-This file contains all BMAD agents configured for use with Qwen Code.
-Agents can be activated by typing \`*{agent-name}\` in your prompts.
+      await this.writeFile(targetPath, content);
 
----
+      agentCount++;
+      console.log(chalk.green(`  ✓ Added agent: /bmad:${agent.module}:agents:${agent.name}`));
+    }
 
-`;
+    // Create TOML files for each task
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readAndProcess(task.path, {
+        module: task.module,
+        name: task.name,
+      });
 
-    let agentCount = 0;
-    for (const agent of agents) {
-      const content = await this.readFile(agent.path);
-      const agentSection = this.createAgentSection(agent, content, projectDir);
+      const targetPath = path.join(bmadCommandsDir, task.module, 'tasks', `${task.name}.toml`);
 
-      concatenatedContent += agentSection;
-      concatenatedContent += '\n\n---\n\n';
-      agentCount++;
+      await this.writeFile(targetPath, content);
 
-      console.log(chalk.green(`  ✓ Added agent: *${agent.name}`));
+      taskCount++;
+      console.log(chalk.green(`  ✓ Added task: /bmad:${task.module}:tasks:${task.name}`));
     }
 
-    // Write QWEN.md
-    const qwenMdPath = path.join(bmadMethodDir, 'QWEN.md');
-    await this.writeFile(qwenMdPath, concatenatedContent);
+    // Create TOML files for each tool
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readAndProcess(tool.path, {
+        module: tool.module,
+        name: tool.name,
+      });
+
+      const targetPath = path.join(bmadCommandsDir, tool.module, 'tools', `${tool.name}.toml`);
+
+      await this.writeFile(targetPath, content);
+
+      toolCount++;
+      console.log(chalk.green(`  ✓ Added tool: /bmad:${tool.module}:tools:${tool.name}`));
+    }
+
+    // Create TOML files for each workflow
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readAndProcess(workflow.path, {
+        module: workflow.module,
+        name: workflow.name,
+      });
+
+      const targetPath = path.join(bmadCommandsDir, workflow.module, 'workflows', `${workflow.name}.toml`);
+
+      await this.writeFile(targetPath, content);
+
+      workflowCount++;
+      console.log(chalk.green(`  ✓ Added workflow: /bmad:${workflow.module}:workflows:${workflow.name}`));
+    }
 
     console.log(chalk.green(`✓ ${this.name} configured:`));
     console.log(chalk.dim(`  - ${agentCount} agents configured`));
-    console.log(chalk.dim(`  - Configuration file: ${path.relative(projectDir, qwenMdPath)}`));
-    console.log(chalk.dim(`  - Agents activated with: *{agent-name}`));
+    console.log(chalk.dim(`  - ${taskCount} tasks configured`));
+    console.log(chalk.dim(`  - ${toolCount} tools configured`));
+    console.log(chalk.dim(`  - ${workflowCount} workflows configured`));
+    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, bmadCommandsDir)}`));
 
     return {
       success: true,
       agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
     };
   }
 
@@ -89,7 +151,9 @@ Agents can be activated by typing \`*{agent-name}\` in your prompts.
         // Remove agent file references from contextFileName
         if (settings.contextFileName && Array.isArray(settings.contextFileName)) {
           const originalLength = settings.contextFileName.length;
-          settings.contextFileName = settings.contextFileName.filter((fileName) => !fileName.startsWith('agents/'));
+          settings.contextFileName = settings.contextFileName.filter(
+            (fileName) => !fileName.startsWith('agents/') && !fileName.startsWith('bmad-method/'),
+          );
 
           if (settings.contextFileName.length !== originalLength) {
             updated = true;
@@ -107,58 +171,84 @@ Agents can be activated by typing \`*{agent-name}\` in your prompts.
   }
 
   /**
-   * Clean up old agents directory
+   * Clean up old configuration directories
    */
-  async cleanupOldAgents(qwenDir) {
+  async cleanupOldConfig(qwenDir) {
     const fs = require('fs-extra');
     const agentsDir = path.join(qwenDir, 'agents');
+    const bmadMethodDir = path.join(qwenDir, 'bmad-method');
+    const bmadDir = path.join(qwenDir, 'bmadDir');
 
     if (await fs.pathExists(agentsDir)) {
       await fs.remove(agentsDir);
       console.log(chalk.green('  ✓ Removed old agents directory'));
     }
+
+    if (await fs.pathExists(bmadMethodDir)) {
+      await fs.remove(bmadMethodDir);
+      console.log(chalk.green('  ✓ Removed old bmad-method directory'));
+    }
+
+    if (await fs.pathExists(bmadDir)) {
+      await fs.remove(bmadDir);
+      console.log(chalk.green('  ✓ Removed old BMad directory'));
+    }
   }
 
   /**
-   * Create agent section for concatenated file
+   * Read and process file content
    */
-  createAgentSection(agent, content, projectDir) {
-    // Extract metadata
-    const titleMatch = content.match(/title="([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
-
-    // Extract YAML content
-    const yamlMatch = content.match(/```ya?ml\r?\n([\s\S]*?)```/);
-    const yamlContent = yamlMatch ? yamlMatch[1] : content;
-
-    // Get relative path
-    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
-
-    let section = `# ${agent.name.toUpperCase()} Agent Rule
-
-This rule is triggered when the user types \`*${agent.name}\` and activates the ${title} agent persona.
-
-## Agent Activation
-
-CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
-
-\`\`\`yaml
-${yamlContent}
-\`\`\`
-
-## File Reference
-
-The complete agent definition is available in [${relativePath}](${relativePath}).
-
-## Usage
-
-When the user types \`*${agent.name}\`, activate this ${title} persona and follow all instructions defined in the YAML configuration above.
-
-## Module
+  async readAndProcess(filePath, metadata) {
+    const fs = require('fs-extra');
+    const content = await fs.readFile(filePath, 'utf8');
+    return this.processContent(content, metadata);
+  }
 
-Part of the BMAD ${agent.module.toUpperCase()} module.`;
+  /**
+   * Override processContent to add TOML metadata header for Qwen
+   * @param {string} content - File content
+   * @param {Object} metadata - File metadata
+   * @returns {string} Processed content with Qwen template
+   */
+  processContent(content, metadata = {}) {
+    // First apply base processing (includes activation injection for agents)
+    let prompt = super.processContent(content, metadata);
+
+    // Determine the type and description based on content
+    const isAgent = content.includes('<agent');
+    const isTask = content.includes('<task');
+    const isTool = content.includes('<tool');
+    const isWorkflow = content.includes('workflow:') || content.includes('name:');
+
+    let description = '';
+
+    if (isAgent) {
+      // Extract agent title if available
+      const titleMatch = content.match(/title="([^"]+)"/);
+      const title = titleMatch ? titleMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Agent: ${title}`;
+    } else if (isTask) {
+      // Extract task name if available
+      const nameMatch = content.match(/name="([^"]+)"/);
+      const taskName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Task: ${taskName}`;
+    } else if (isTool) {
+      // Extract tool name if available
+      const nameMatch = content.match(/name="([^"]+)"/);
+      const toolName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `BMAD ${metadata.module.toUpperCase()} Tool: ${toolName}`;
+    } else if (isWorkflow) {
+      // Workflow
+      description = `BMAD ${metadata.module.toUpperCase()} Workflow: ${metadata.name}`;
+    } else {
+      description = `BMAD ${metadata.module.toUpperCase()}: ${metadata.name}`;
+    }
 
-    return section;
+    return `description = "${description}"
+prompt = """
+${prompt}
+"""
+`;
   }
 
   /**
@@ -176,12 +266,24 @@ Part of the BMAD ${agent.module.toUpperCase()} module.`;
    */
   async cleanup(projectDir) {
     const fs = require('fs-extra');
-    const bmadMethodDir = path.join(projectDir, this.configDir, this.bmadDir);
+    const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, this.bmadDir);
+    const oldBmadMethodDir = path.join(projectDir, this.configDir, 'bmad-method');
+    const oldBMadDir = path.join(projectDir, this.configDir, 'BMad');
 
-    if (await fs.pathExists(bmadMethodDir)) {
-      await fs.remove(bmadMethodDir);
+    if (await fs.pathExists(bmadCommandsDir)) {
+      await fs.remove(bmadCommandsDir);
       console.log(chalk.dim(`Removed BMAD configuration from Qwen Code`));
     }
+
+    if (await fs.pathExists(oldBmadMethodDir)) {
+      await fs.remove(oldBmadMethodDir);
+      console.log(chalk.dim(`Removed old BMAD configuration from Qwen Code`));
+    }
+
+    if (await fs.pathExists(oldBMadDir)) {
+      await fs.remove(oldBMadDir);
+      console.log(chalk.dim(`Removed old BMAD configuration from Qwen Code`));
+    }
   }
 }
 

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

@@ -0,0 +1,143 @@
+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) {
+  const agents = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return agents;
+  }
+
+  const files = await fs.readdir(dirPath);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) {
+      continue;
+    }
+
+    if (file.includes('.customize.')) {
+      continue;
+    }
+
+    const filePath = path.join(dirPath, file);
+    const content = await fs.readFile(filePath, 'utf8');
+
+    if (content.includes('localskip="true"')) {
+      continue;
+    }
+
+    agents.push({
+      path: filePath,
+      name: file.replace('.md', ''),
+      module: moduleName,
+    });
+  }
+
+  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,133 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-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.load(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) {
+    const pattern = path.join(sourceDir, '**', 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,
+};