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

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

@@ -1,16 +1,18 @@
 const path = require('node:path');
-const { BaseIdeSetup } = require('./_base-ide');
+const fs = require('fs-extra');
+const os = require('node:os');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
+const { BaseIdeSetup } = require('./_base-ide');
+const { WorkflowCommandGenerator } = require('./workflow-command-generator');
+const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');
 
 /**
  * Codex setup handler (supports both CLI and Web)
- * Creates comprehensive AGENTS.md file in project root
  */
 class CodexSetup extends BaseIdeSetup {
   constructor() {
     super('codex', 'Codex', true); // preferred IDE
-    this.agentsFile = 'AGENTS.md';
   }
 
   /**
@@ -44,223 +46,188 @@ class CodexSetup extends BaseIdeSetup {
   async setup(projectDir, bmadDir, options = {}) {
     console.log(chalk.cyan(`Setting up ${this.name}...`));
 
-    // Use pre-collected configuration if available
     const config = options.preCollectedConfig || {};
     const mode = config.codexMode || options.codexMode || 'cli';
 
-    // Get agents and tasks
-    const agents = await this.getAgents(bmadDir);
-    const tasks = await this.getTasks(bmadDir);
-
-    // Create AGENTS.md content
-    const content = this.createAgentsDocument(agents, tasks, mode);
-
-    // Write AGENTS.md file
-    const agentsPath = path.join(projectDir, this.agentsFile);
-    await this.writeFile(agentsPath, content);
+    const { artifacts, counts } = await this.collectClaudeArtifacts(projectDir, bmadDir, options);
 
-    // Handle mode-specific setup
-    if (mode === 'web') {
-      await this.setupWebMode(projectDir);
-    } else {
-      await this.setupCliMode(projectDir);
-    }
+    const destDir = this.getCodexPromptDir();
+    await fs.ensureDir(destDir);
+    await this.clearOldBmadFiles(destDir);
+    const written = await this.flattenAndWriteArtifacts(artifacts, destDir);
 
     console.log(chalk.green(`✓ ${this.name} configured:`));
     console.log(chalk.dim(`  - Mode: ${mode === 'web' ? 'Web' : 'CLI'}`));
-    console.log(chalk.dim(`  - ${agents.length} agents documented`));
-    console.log(chalk.dim(`  - ${tasks.length} tasks documented`));
-    console.log(chalk.dim(`  - Agents file: ${this.agentsFile}`));
+    console.log(chalk.dim(`  - ${counts.agents} agents exported`));
+    console.log(chalk.dim(`  - ${counts.tasks} tasks exported`));
+    console.log(chalk.dim(`  - ${counts.workflows} workflow commands exported`));
+    if (counts.workflowLaunchers > 0) {
+      console.log(chalk.dim(`  - ${counts.workflowLaunchers} workflow launchers exported`));
+    }
+    if (counts.subagents > 0) {
+      console.log(chalk.dim(`  - ${counts.subagents} subagents exported`));
+    }
+    console.log(chalk.dim(`  - ${written} Codex prompt files written`));
+    console.log(chalk.dim(`  - Destination: ${destDir}`));
+
+    // Prominent notice about home directory installation
+    console.log('');
+    console.log(chalk.bold.cyan('═'.repeat(70)));
+    console.log(chalk.bold.yellow('  IMPORTANT: Codex Configuration'));
+    console.log(chalk.bold.cyan('═'.repeat(70)));
+    console.log('');
+    console.log(chalk.white('  Prompts have been installed to your HOME DIRECTORY, not this project.'));
+    console.log(chalk.white('  No .codex file was created in the project root.'));
+    console.log('');
+    console.log(chalk.green('  ✓ You can now use slash commands (/) in Codex CLI'));
+    console.log(chalk.dim('    Example: /bmad-bmm-agents-pm'));
+    console.log(chalk.dim('    Type / to see all available commands'));
+    console.log('');
+    console.log(chalk.bold.cyan('═'.repeat(70)));
+    console.log('');
 
     return {
       success: true,
       mode,
-      agents: agents.length,
-      tasks: tasks.length,
+      artifacts,
+      counts,
+      destination: destDir,
+      written,
     };
   }
 
   /**
-   * Select Codex mode (CLI or Web)
+   * Detect Codex installation by checking for BMAD prompt exports
    */
-  async selectMode() {
-    const response = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'mode',
-        message: 'Select Codex deployment mode:',
-        choices: [
-          { name: 'CLI (Command-line interface)', value: 'cli' },
-          { name: 'Web (Browser-based interface)', value: 'web' },
-        ],
-        default: 'cli',
-      },
-    ]);
+  async detect(_projectDir) {
+    const destDir = this.getCodexPromptDir();
+
+    if (!(await fs.pathExists(destDir))) {
+      return false;
+    }
 
-    return response.mode;
+    const entries = await fs.readdir(destDir);
+    return entries.some((entry) => entry.startsWith('bmad-'));
   }
 
   /**
-   * Create comprehensive agents document
+   * Collect Claude-style artifacts for Codex export.
+   * Returns the normalized artifact list for further processing.
    */
-  createAgentsDocument(agents, tasks, mode) {
-    let content = `# BMAD Method - Agent Directory
-
-This document contains all available BMAD agents and tasks for use with Codex ${mode === 'web' ? 'Web' : 'CLI'}.
-
-## Quick Start
-
-${
-  mode === 'web'
-    ? `Access agents through the web interface:
-1. Navigate to the Agents section
-2. Select an agent to activate
-3. The agent persona will be active for your session`
-    : `Activate agents in CLI:
-1. Reference agents using \`@{agent-name}\`
-2. Execute tasks using \`@task-{task-name}\`
-3. Agents remain active for the conversation`
-}
-
----
-
-## Available Agents
+  async collectClaudeArtifacts(projectDir, bmadDir, options = {}) {
+    const selectedModules = options.selectedModules || [];
+    const artifacts = [];
 
-`;
-
-    // Group agents by module
-    const agentsByModule = {};
+    const agents = await getAgentsFromBmad(bmadDir, selectedModules);
     for (const agent of agents) {
-      if (!agentsByModule[agent.module]) {
-        agentsByModule[agent.module] = [];
-      }
-      agentsByModule[agent.module].push(agent);
-    }
-
-    // Document each module's agents
-    for (const [module, moduleAgents] of Object.entries(agentsByModule)) {
-      content += `### ${module.toUpperCase()} Module\n\n`;
-
-      for (const agent of moduleAgents) {
-        const agentContent = this.readFileSync(agent.path);
-        const titleMatch = agentContent.match(/title="([^"]+)"/);
-        const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
-
-        const iconMatch = agentContent.match(/icon="([^"]+)"/);
-        const icon = iconMatch ? iconMatch[1] : '🤖';
-
-        const whenToUseMatch = agentContent.match(/whenToUse="([^"]+)"/);
-        const whenToUse = whenToUseMatch ? whenToUseMatch[1] : `Use for ${title} tasks`;
-
-        content += `#### ${icon} ${title} (\`@${agent.name}\`)\n\n`;
-        content += `**When to use:** ${whenToUse}\n\n`;
-        content += `**Activation:** Type \`@${agent.name}\` to activate this agent.\n\n`;
-      }
+      const content = await this.readAndProcessWithProject(
+        agent.path,
+        {
+          module: agent.module,
+          name: agent.name,
+        },
+        projectDir,
+      );
+
+      artifacts.push({
+        type: 'agent',
+        module: agent.module,
+        sourcePath: agent.path,
+        relativePath: path.join(agent.module, 'agents', `${agent.name}.md`),
+        content,
+      });
     }
 
-    content += `---
-
-## Available Tasks
-
-`;
-
-    // Group tasks by module
-    const tasksByModule = {};
+    const tasks = await getTasksFromBmad(bmadDir, selectedModules);
     for (const task of tasks) {
-      if (!tasksByModule[task.module]) {
-        tasksByModule[task.module] = [];
-      }
-      tasksByModule[task.module].push(task);
+      const content = await this.readAndProcessWithProject(
+        task.path,
+        {
+          module: task.module,
+          name: task.name,
+        },
+        projectDir,
+      );
+
+      artifacts.push({
+        type: 'task',
+        module: task.module,
+        sourcePath: task.path,
+        relativePath: path.join(task.module, 'tasks', `${task.name}.md`),
+        content,
+      });
     }
 
-    // Document each module's tasks
-    for (const [module, moduleTasks] of Object.entries(tasksByModule)) {
-      content += `### ${module.toUpperCase()} Module Tasks\n\n`;
-
-      for (const task of moduleTasks) {
-        const taskContent = this.readFileSync(task.path);
-        const nameMatch = taskContent.match(/<name>([^<]+)<\/name>/);
-        const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
-
-        content += `- **${taskName}** (\`@task-${task.name}\`)\n`;
-      }
-      content += '\n';
-    }
+    const workflowGenerator = new WorkflowCommandGenerator();
+    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
+    artifacts.push(...workflowArtifacts);
 
-    content += `---
+    return {
+      artifacts,
+      counts: {
+        agents: agents.length,
+        tasks: tasks.length,
+        workflows: workflowCounts.commands,
+        workflowLaunchers: workflowCounts.launchers,
+      },
+    };
+  }
 
-## Usage Guidelines
+  getCodexPromptDir() {
+    return path.join(os.homedir(), '.codex', 'prompts');
+  }
 
-1. **One agent at a time**: Activate a single agent for focused assistance
-2. **Task execution**: Tasks are one-time workflows, not persistent personas
-3. **Module organization**: Agents and tasks are grouped by their source module
-4. **Context preservation**: ${mode === 'web' ? 'Sessions maintain agent context' : 'Conversations maintain agent context'}
+  flattenFilename(relativePath) {
+    const sanitized = relativePath.replaceAll(/[\\/]/g, '-');
+    return `bmad-${sanitized}`;
+  }
 
----
+  async flattenAndWriteArtifacts(artifacts, destDir) {
+    let written = 0;
 
-*Generated by BMAD Method installer for Codex ${mode === 'web' ? 'Web' : 'CLI'}*
-`;
+    for (const artifact of artifacts) {
+      const flattenedName = this.flattenFilename(artifact.relativePath);
+      const targetPath = path.join(destDir, flattenedName);
+      await fs.writeFile(targetPath, artifact.content);
+      written++;
+    }
 
-    return content;
+    return written;
   }
 
-  /**
-   * Read file synchronously (for document generation)
-   */
-  readFileSync(filePath) {
-    const fs = require('node:fs');
-    try {
-      return fs.readFileSync(filePath, 'utf8');
-    } catch {
-      return '';
+  async clearOldBmadFiles(destDir) {
+    if (!(await fs.pathExists(destDir))) {
+      return;
     }
-  }
 
-  /**
-   * Setup for CLI mode
-   */
-  async setupCliMode(projectDir) {
-    // CLI mode - ensure .gitignore includes AGENTS.md if needed
-    const fs = require('fs-extra');
-    const gitignorePath = path.join(projectDir, '.gitignore');
-
-    if (await fs.pathExists(gitignorePath)) {
-      const gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
-      if (!gitignoreContent.includes('AGENTS.md')) {
-        // User can decide whether to track this file
-        console.log(chalk.dim('  Note: Consider adding AGENTS.md to .gitignore if desired'));
+    const entries = await fs.readdir(destDir);
+
+    for (const entry of entries) {
+      if (!entry.startsWith('bmad-')) {
+        continue;
       }
-    }
-  }
 
-  /**
-   * Setup for Web mode
-   */
-  async setupWebMode(projectDir) {
-    // Web mode - add to .gitignore to avoid committing
-    const fs = require('fs-extra');
-    const gitignorePath = path.join(projectDir, '.gitignore');
-
-    if (await fs.pathExists(gitignorePath)) {
-      const gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
-      if (!gitignoreContent.includes('AGENTS.md')) {
-        await fs.appendFile(gitignorePath, '\n# Codex Web agents file\nAGENTS.md\n');
-        console.log(chalk.dim('  Added AGENTS.md to .gitignore for web deployment'));
+      const entryPath = path.join(destDir, entry);
+      const stat = await fs.stat(entryPath);
+      if (stat.isFile()) {
+        await fs.remove(entryPath);
+      } else if (stat.isDirectory()) {
+        await fs.remove(entryPath);
       }
     }
   }
 
+  async readAndProcessWithProject(filePath, metadata, projectDir) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return super.processContent(content, metadata, projectDir);
+  }
+
   /**
-   * Cleanup Codex configuration
+   * Cleanup Codex configuration (no-op until export destination is finalized)
    */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const agentsPath = path.join(projectDir, this.agentsFile);
-
-    if (await fs.pathExists(agentsPath)) {
-      await fs.remove(agentsPath);
-      console.log(chalk.dim('Removed AGENTS.md file'));
-    }
+  async cleanup() {
+    const destDir = this.getCodexPromptDir();
+    await this.clearOldBmadFiles(destDir);
   }
 }
 

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

@@ -25,79 +25,69 @@ class CrushSetup extends BaseIdeSetup {
     // Create .crush/commands/bmad directory structure
     const crushDir = path.join(projectDir, this.configDir);
     const commandsDir = path.join(crushDir, this.commandsDir, 'bmad');
-    const agentsDir = path.join(commandsDir, 'agents');
-    const tasksDir = path.join(commandsDir, 'tasks');
 
-    await this.ensureDir(agentsDir);
-    await this.ensureDir(tasksDir);
+    await this.ensureDir(commandsDir);
 
-    // Get agents and tasks
+    // Get agents, tasks, tools, and workflows (standalone only)
     const agents = await this.getAgents(bmadDir);
-    const tasks = await this.getTasks(bmadDir);
+    const tasks = await this.getTasks(bmadDir, true);
+    const tools = await this.getTools(bmadDir, true);
+    const workflows = await this.getWorkflows(bmadDir, true);
 
-    // Setup agents as commands
-    let agentCount = 0;
-    for (const agent of agents) {
-      const content = await this.readFile(agent.path);
-      const commandContent = this.createAgentCommand(agent, content, projectDir);
-
-      const targetPath = path.join(agentsDir, `${agent.module}-${agent.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-      agentCount++;
-    }
-
-    // Setup tasks as commands
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readFile(task.path);
-      const commandContent = this.createTaskCommand(task, content);
-
-      const targetPath = path.join(tasksDir, `${task.module}-${task.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-      taskCount++;
-    }
-
-    // Create module-specific subdirectories for better organization
-    await this.organizeByModule(commandsDir, agents, tasks, bmadDir);
+    // Organize by module
+    const agentCount = await this.organizeByModule(commandsDir, agents, tasks, tools, workflows, projectDir);
 
     console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agent commands created`));
-    console.log(chalk.dim(`  - ${taskCount} task commands created`));
+    console.log(chalk.dim(`  - ${agentCount.agents} agent commands created`));
+    console.log(chalk.dim(`  - ${agentCount.tasks} task commands created`));
+    console.log(chalk.dim(`  - ${agentCount.tools} tool commands created`));
+    console.log(chalk.dim(`  - ${agentCount.workflows} workflow commands created`));
     console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
     console.log(chalk.dim('\n  Commands can be accessed via Crush command palette'));
 
     return {
       success: true,
-      agents: agentCount,
-      tasks: taskCount,
+      ...agentCount,
     };
   }
 
   /**
    * Organize commands by module
    */
-  async organizeByModule(commandsDir, agents, tasks, bmadDir) {
+  async organizeByModule(commandsDir, agents, tasks, tools, workflows, projectDir) {
     // Get unique modules
     const modules = new Set();
     for (const agent of agents) modules.add(agent.module);
     for (const task of tasks) modules.add(task.module);
+    for (const tool of tools) modules.add(tool.module);
+    for (const workflow of workflows) modules.add(workflow.module);
+
+    let agentCount = 0;
+    let taskCount = 0;
+    let toolCount = 0;
+    let workflowCount = 0;
 
     // Create module directories
     for (const module of modules) {
       const moduleDir = path.join(commandsDir, module);
       const moduleAgentsDir = path.join(moduleDir, 'agents');
       const moduleTasksDir = path.join(moduleDir, 'tasks');
+      const moduleToolsDir = path.join(moduleDir, 'tools');
+      const moduleWorkflowsDir = path.join(moduleDir, 'workflows');
 
       await this.ensureDir(moduleAgentsDir);
       await this.ensureDir(moduleTasksDir);
+      await this.ensureDir(moduleToolsDir);
+      await this.ensureDir(moduleWorkflowsDir);
 
       // Copy module-specific agents
       const moduleAgents = agents.filter((a) => a.module === module);
       for (const agent of moduleAgents) {
         const content = await this.readFile(agent.path);
-        const commandContent = this.createAgentCommand(agent, content, bmadDir);
+        const commandContent = this.createAgentCommand(agent, content, projectDir);
         const targetPath = path.join(moduleAgentsDir, `${agent.name}.md`);
         await this.writeFile(targetPath, commandContent);
+        agentCount++;
       }
 
       // Copy module-specific tasks
@@ -107,8 +97,36 @@ class CrushSetup extends BaseIdeSetup {
         const commandContent = this.createTaskCommand(task, content);
         const targetPath = path.join(moduleTasksDir, `${task.name}.md`);
         await this.writeFile(targetPath, commandContent);
+        taskCount++;
+      }
+
+      // Copy module-specific tools
+      const moduleTools = tools.filter((t) => t.module === module);
+      for (const tool of moduleTools) {
+        const content = await this.readFile(tool.path);
+        const commandContent = this.createToolCommand(tool, content);
+        const targetPath = path.join(moduleToolsDir, `${tool.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        toolCount++;
+      }
+
+      // Copy module-specific workflows
+      const moduleWorkflows = workflows.filter((w) => w.module === module);
+      for (const workflow of moduleWorkflows) {
+        const content = await this.readFile(workflow.path);
+        const commandContent = this.createWorkflowCommand(workflow, content);
+        const targetPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        workflowCount++;
       }
     }
+
+    return {
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
   }
 
   /**
@@ -154,7 +172,7 @@ Part of the BMAD ${agent.module.toUpperCase()} module.
    */
   createTaskCommand(task, content) {
     // Extract task name
-    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+    const nameMatch = content.match(/name="([^"]+)"/);
     const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
 
     let commandContent = `# /task-${task.name} Command
@@ -177,6 +195,60 @@ Part of the BMAD ${task.module.toUpperCase()} module.
     return commandContent;
   }
 
+  /**
+   * Create tool command content
+   */
+  createToolCommand(tool, content) {
+    // Extract tool name
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const toolName = nameMatch ? nameMatch[1] : this.formatTitle(tool.name);
+
+    let commandContent = `# /tool-${tool.name} Command
+
+When this command is used, execute the following tool:
+
+## ${toolName} Tool
+
+${content}
+
+## Command Usage
+
+This command executes the ${toolName} tool from the BMAD ${tool.module.toUpperCase()} module.
+
+## Module
+
+Part of the BMAD ${tool.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Create workflow command content
+   */
+  createWorkflowCommand(workflow, content) {
+    const workflowName = workflow.name ? this.formatTitle(workflow.name) : 'Workflow';
+
+    let commandContent = `# /${workflow.name} Command
+
+When this command is used, execute the following workflow:
+
+## ${workflowName} Workflow
+
+${content}
+
+## Command Usage
+
+This command executes the ${workflowName} workflow from the BMAD ${workflow.module.toUpperCase()} module.
+
+## Module
+
+Part of the BMAD ${workflow.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
   /**
    * Format name as title
    */