mdan-cli 2.5.0 → 2.5.2

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

@@ -0,0 +1,366 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const { toColonName, toColonPath, toDashPath, BMAD_FOLDER_NAME } = require('./path-utils');
+
+/**
+ * Generates command files for standalone tasks and tools
+ */
+class TaskToolCommandGenerator {
+  /**
+   * @param {string} bmadFolderName - Name of the BMAD folder for template rendering (default: '_bmad')
+   * Note: This parameter is accepted for API consistency with AgentCommandGenerator and
+   * WorkflowCommandGenerator, but is not used for path stripping. The manifest always stores
+   * filesystem paths with '_bmad/' prefix (the actual folder name), while bmadFolderName is
+   * used for template placeholder rendering ({{bmadFolderName}}).
+   */
+  constructor(bmadFolderName = BMAD_FOLDER_NAME) {
+    this.bmadFolderName = bmadFolderName;
+  }
+
+  /**
+   * Collect task and tool artifacts for IDE installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {Promise<Object>} Artifacts array with metadata
+   */
+  async collectTaskToolArtifacts(bmadDir) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    // All tasks/tools in manifest are standalone (internal=true items are filtered during manifest generation)
+    const artifacts = [];
+    const bmadPrefix = `${BMAD_FOLDER_NAME}/`;
+
+    // Collect task artifacts
+    for (const task of tasks || []) {
+      let taskPath = (task.path || '').replaceAll('\\', '/');
+      // Convert absolute paths to relative paths
+      if (path.isAbsolute(taskPath)) {
+        taskPath = path.relative(bmadDir, taskPath).replaceAll('\\', '/');
+      }
+      // Remove _bmad/ prefix if present to get relative path within bmad folder
+      if (taskPath.startsWith(bmadPrefix)) {
+        taskPath = taskPath.slice(bmadPrefix.length);
+      }
+
+      const taskExt = path.extname(taskPath) || '.md';
+      artifacts.push({
+        type: 'task',
+        name: task.name,
+        displayName: task.displayName || task.name,
+        description: task.description || `Execute ${task.displayName || task.name}`,
+        module: task.module,
+        // Use forward slashes for cross-platform consistency (not path.join which uses backslashes on Windows)
+        relativePath: `${task.module}/tasks/${task.name}${taskExt}`,
+        path: taskPath,
+      });
+    }
+
+    // Collect tool artifacts
+    for (const tool of tools || []) {
+      let toolPath = (tool.path || '').replaceAll('\\', '/');
+      // Convert absolute paths to relative paths
+      if (path.isAbsolute(toolPath)) {
+        toolPath = path.relative(bmadDir, toolPath).replaceAll('\\', '/');
+      }
+      // Remove _bmad/ prefix if present to get relative path within bmad folder
+      if (toolPath.startsWith(bmadPrefix)) {
+        toolPath = toolPath.slice(bmadPrefix.length);
+      }
+
+      const toolExt = path.extname(toolPath) || '.md';
+      artifacts.push({
+        type: 'tool',
+        name: tool.name,
+        displayName: tool.displayName || tool.name,
+        description: tool.description || `Execute ${tool.displayName || tool.name}`,
+        module: tool.module,
+        // Use forward slashes for cross-platform consistency (not path.join which uses backslashes on Windows)
+        relativePath: `${tool.module}/tools/${tool.name}${toolExt}`,
+        path: toolPath,
+      });
+    }
+
+    return {
+      artifacts,
+      counts: {
+        tasks: (tasks || []).length,
+        tools: (tools || []).length,
+      },
+    };
+  }
+
+  /**
+   * 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);
+
+    // 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 tasks || []) {
+      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 tools || []) {
+      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: (tasks || []).length,
+      tools: (tools || []).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
+    // Handle undefined/missing path by constructing from module and name
+    let itemPath = item.path;
+    if (!itemPath || typeof itemPath !== 'string') {
+      // Fallback: construct path from module and name if path is missing
+      const typePlural = type === 'task' ? 'tasks' : 'tools';
+      itemPath = `{project-root}/${this.bmadFolderName}/${item.module}/${typePlural}/${item.name}.md`;
+    } else {
+      // Normalize path separators to forward slashes
+      itemPath = itemPath.replaceAll('\\', '/');
+
+      // Extract relative path from absolute paths (Windows or Unix)
+      // Look for _bmad/ or bmad/ in the path and extract everything after it
+      // Match patterns like: /_bmad/core/tasks/... or /bmad/core/tasks/...
+      // Use [/\\] to handle both Unix forward slashes and Windows backslashes,
+      // and also paths without a leading separator (e.g., C:/_bmad/...)
+      const bmadMatch = itemPath.match(/[/\\]_bmad[/\\](.+)$/) || itemPath.match(/[/\\]bmad[/\\](.+)$/);
+      if (bmadMatch) {
+        // Found /_bmad/ or /bmad/ - use relative path after it
+        itemPath = `{project-root}/${this.bmadFolderName}/${bmadMatch[1]}`;
+      } else if (itemPath.startsWith(`${BMAD_FOLDER_NAME}/`)) {
+        // Relative path starting with _bmad/
+        itemPath = `{project-root}/${this.bmadFolderName}/${itemPath.slice(BMAD_FOLDER_NAME.length + 1)}`;
+      } else if (itemPath.startsWith('bmad/')) {
+        // Relative path starting with bmad/
+        itemPath = `{project-root}/${this.bmadFolderName}/${itemPath.slice(5)}`;
+      } else if (!itemPath.startsWith('{project-root}')) {
+        // For other relative paths, prefix with project root and bmad folder
+        itemPath = `{project-root}/${this.bmadFolderName}/${itemPath}`;
+      }
+    }
+
+    return `---
+description: '${description.replaceAll("'", "''")}'
+---
+
+# ${item.displayName || item.name}
+
+Read the entire ${type} file 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,
+    });
+  }
+
+  /**
+   * Generate task and tool commands using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_help.md
+   *
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @returns {Object} Generation results
+   */
+  async generateColonTaskToolCommands(projectDir, bmadDir, baseCommandsDir) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    let generatedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of tasks || []) {
+      const commandContent = this.generateCommandContent(task, 'task');
+      // Use underscore format: bmad_bmm_name.md
+      const flatName = toColonName(task.module, 'tasks', task.name);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of tools || []) {
+      const commandContent = this.generateCommandContent(tool, 'tool');
+      // Use underscore format: bmad_bmm_name.md
+      const flatName = toColonName(tool.module, 'tools', tool.name);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: (tasks || []).length,
+      tools: (tools || []).length,
+    };
+  }
+
+  /**
+   * Generate task and tool commands using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_help.md
+   *
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @returns {Object} Generation results
+   */
+  async generateDashTaskToolCommands(projectDir, bmadDir, baseCommandsDir) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    let generatedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of tasks || []) {
+      const commandContent = this.generateCommandContent(task, 'task');
+      // Use dash format: bmad-bmm-name.md
+      const flatName = toDashPath(`${task.module}/tasks/${task.name}.md`);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of tools || []) {
+      const commandContent = this.generateCommandContent(tool, 'tool');
+      // Use dash format: bmad-bmm-name.md
+      const flatName = toDashPath(`${tool.module}/tools/${tool.name}.md`);
+      const commandPath = path.join(baseCommandsDir, flatName);
+      await fs.ensureDir(path.dirname(commandPath));
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: (tasks || []).length,
+      tools: (tools || []).length,
+    };
+  }
+
+  /**
+   * Write task/tool artifacts using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_help.md
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Task/tool artifacts with relativePath
+   * @returns {number} Count of commands written
+   */
+  async writeColonArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'task' || artifact.type === 'tool') {
+        const commandContent = this.generateCommandContent(artifact, artifact.type);
+        // Use underscore format: bmad_module_name.md
+        const flatName = toColonPath(artifact.relativePath);
+        const commandPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(commandPath));
+        await fs.writeFile(commandPath, commandContent);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+
+  /**
+   * Write task/tool artifacts using dash format (NEW STANDARD)
+   * Creates flat files like: bmad-bmm-help.md
+   *
+   * Note: Tasks/tools do NOT have bmad-agent- prefix - only agents do.
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Task/tool artifacts with relativePath
+   * @returns {number} Count of commands written
+   */
+  async writeDashArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'task' || artifact.type === 'tool') {
+        const commandContent = this.generateCommandContent(artifact, artifact.type);
+        // Use dash format: bmad-module-name.md
+        const flatName = toDashPath(artifact.relativePath);
+        const commandPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(commandPath));
+        await fs.writeFile(commandPath, commandContent);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+}
+
+module.exports = { TaskToolCommandGenerator };

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

@@ -0,0 +1,318 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const prompts = require('../../../../lib/prompts');
+const { toColonPath, toDashPath, customAgentColonName, customAgentDashName, BMAD_FOLDER_NAME } = require('./path-utils');
+
+/**
+ * Generates command files for each workflow in the manifest
+ */
+class WorkflowCommandGenerator {
+  constructor(bmadFolderName = BMAD_FOLDER_NAME) {
+    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) {
+      await prompts.log.warn('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);
+      // Calculate the relative workflow path (e.g., bmm/workflows/4-implementation/sprint-planning/workflow.yaml)
+      let workflowRelPath = workflow.path || '';
+      // Normalize path separators for cross-platform compatibility
+      workflowRelPath = workflowRelPath.replaceAll('\\', '/');
+      // Remove _bmad/ prefix if present to get relative path from project root
+      // Handle both absolute paths (/path/to/_bmad/...) and relative paths (_bmad/...)
+      if (workflowRelPath.includes('_bmad/')) {
+        const parts = workflowRelPath.split(/_bmad\//);
+        if (parts.length > 1) {
+          workflowRelPath = parts.slice(1).join('/');
+        }
+      } else if (workflowRelPath.includes('/src/')) {
+        // Normalize source paths (e.g. .../src/bmm/...) to relative module path (e.g. bmm/...)
+        const match = workflowRelPath.match(/\/src\/([^/]+)\/(.+)/);
+        if (match) {
+          workflowRelPath = `${match[1]}/${match[2]}`;
+        }
+      }
+      // Determine if this is a YAML workflow (use normalized path which is guaranteed to be a string)
+      const isYamlWorkflow = workflowRelPath.endsWith('.yaml') || workflowRelPath.endsWith('.yml');
+      artifacts.push({
+        type: 'workflow-command',
+        isYamlWorkflow: isYamlWorkflow, // For template selection
+        name: workflow.name,
+        description: workflow.description || `${workflow.name} workflow`,
+        module: workflow.module,
+        relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
+        workflowPath: workflowRelPath, // Relative path to actual workflow file
+        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);
+  }
+
+  /**
+   * 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,
+    });
+  }
+
+  /**
+   * Write workflow command artifacts using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_correct-course.md
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Workflow artifacts
+   * @returns {number} Count of commands written
+   */
+  async writeColonArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'workflow-command') {
+        // Convert relativePath to underscore format: bmm/workflows/correct-course.md → bmad_bmm_correct-course.md
+        const flatName = toColonPath(artifact.relativePath);
+        const commandPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(commandPath));
+        await fs.writeFile(commandPath, artifact.content);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+
+  /**
+   * Write workflow command artifacts using dash format (NEW STANDARD)
+   * Creates flat files like: bmad-bmm-correct-course.md
+   *
+   * Note: Workflows do NOT have bmad-agent- prefix - only agents do.
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Workflow artifacts
+   * @returns {number} Count of commands written
+   */
+  async writeDashArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'workflow-command') {
+        // Convert relativePath to dash format: bmm/workflows/correct-course.md → bmad-bmm-correct-course.md
+        const flatName = toDashPath(artifact.relativePath);
+        const commandPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(commandPath));
+        await fs.writeFile(commandPath, artifact.content);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+}
+
+module.exports = { WorkflowCommandGenerator };

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

@@ -0,0 +1,14 @@
+---
+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>