bmad-method 6.0.0-alpha.8 → 6.0.1

package/tools/cli/installers/lib/ide/shared/path-utils.js

@@ -0,0 +1,299 @@
+/**
+ * Path transformation utilities for IDE installer standardization
+ *
+ * Provides utilities to convert hierarchical paths to flat naming conventions.
+ *
+ * DASH-BASED NAMING (new standard):
+ * - Agents: bmad-agent-module-name.md (with bmad-agent- prefix)
+ * - Workflows/Tasks/Tools: bmad-module-name.md
+ *
+ * Example outputs:
+ * - cis/agents/storymaster.md → bmad-agent-cis-storymaster.md
+ * - bmm/workflows/plan-project.md → bmad-bmm-plan-project.md
+ * - bmm/tasks/create-story.md → bmad-bmm-create-story.md
+ * - core/agents/brainstorming.md → bmad-agent-brainstorming.md (core agents skip module name)
+ */
+
+// Type segments - agents are included in naming, others are filtered out
+const TYPE_SEGMENTS = ['workflows', 'tasks', 'tools'];
+const AGENT_SEGMENT = 'agents';
+
+// BMAD installation folder name - centralized constant for all installers
+const BMAD_FOLDER_NAME = '_bmad';
+
+/**
+ * Convert hierarchical path to flat dash-separated name (NEW STANDARD)
+ * Converts: 'bmm', 'agents', 'pm' → 'bmad-agent-bmm-pm.md'
+ * Converts: 'bmm', 'workflows', 'correct-course' → 'bmad-bmm-correct-course.md'
+ * Converts: 'core', 'agents', 'brainstorming' → 'bmad-agent-brainstorming.md' (core agents skip module name)
+ *
+ * @param {string} module - Module name (e.g., 'bmm', 'core')
+ * @param {string} type - Artifact type ('agents', 'workflows', 'tasks', 'tools')
+ * @param {string} name - Artifact name (e.g., 'pm', 'brainstorming')
+ * @returns {string} Flat filename like 'bmad-agent-bmm-pm.md' or 'bmad-bmm-correct-course.md'
+ */
+function toDashName(module, type, name) {
+  const isAgent = type === AGENT_SEGMENT;
+
+  // For core module, skip the module name: use 'bmad-agent-name.md' instead of 'bmad-agent-core-name.md'
+  if (module === 'core') {
+    return isAgent ? `bmad-agent-${name}.md` : `bmad-${name}.md`;
+  }
+
+  // Module artifacts: bmad-module-name.md or bmad-agent-module-name.md
+  // eslint-disable-next-line unicorn/prefer-string-replace-all -- regex replace is intentional here
+  const dashName = name.replace(/\//g, '-'); // Flatten nested paths
+  return isAgent ? `bmad-agent-${module}-${dashName}.md` : `bmad-${module}-${dashName}.md`;
+}
+
+/**
+ * Convert relative path to flat dash-separated name
+ * Converts: 'bmm/agents/pm.md' → 'bmad-agent-bmm-pm.md'
+ * Converts: 'bmm/agents/tech-writer/tech-writer.md' → 'bmad-agent-bmm-tech-writer.md' (uses folder name)
+ * Converts: 'bmm/workflows/correct-course.md' → 'bmad-bmm-correct-course.md'
+ * Converts: 'core/agents/brainstorming.md' → 'bmad-agent-brainstorming.md' (core agents skip module name)
+ *
+ * @param {string} relativePath - Path like 'bmm/agents/pm.md'
+ * @returns {string} Flat filename like 'bmad-agent-bmm-pm.md' or 'bmad-brainstorming.md'
+ */
+function toDashPath(relativePath) {
+  if (!relativePath || typeof relativePath !== 'string') {
+    // Return a safe default for invalid input
+    return 'bmad-unknown.md';
+  }
+
+  // Strip common file extensions to avoid double extensions in generated filenames
+  // e.g., 'create-story.xml' → 'create-story', 'workflow.yaml' → 'workflow'
+  const withoutExt = relativePath.replace(/\.(md|yaml|yml|json|xml|toml)$/i, '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1];
+  let name;
+
+  // For agents, if nested in a folder (more than 3 parts), use the folder name only
+  // e.g., 'bmm/agents/tech-writer/tech-writer' → 'tech-writer' (not 'tech-writer-tech-writer')
+  if (type === 'agents' && parts.length > 3) {
+    // Use the folder name (parts[2]) as the name, ignore the file name
+    name = parts[2];
+  } else {
+    // For non-nested or non-agents, join all parts after type
+    name = parts.slice(2).join('-');
+  }
+
+  return toDashName(module, type, name);
+}
+
+/**
+ * Create custom agent dash name
+ * Creates: 'bmad-custom-agent-fred-commit-poet.md'
+ *
+ * @param {string} agentName - Custom agent name
+ * @returns {string} Flat filename like 'bmad-custom-agent-fred-commit-poet.md'
+ */
+function customAgentDashName(agentName) {
+  return `bmad-custom-agent-${agentName}.md`;
+}
+
+/**
+ * Check if a filename uses dash format
+ * @param {string} filename - Filename to check
+ * @returns {boolean} True if filename uses dash format
+ */
+function isDashFormat(filename) {
+  return filename.startsWith('bmad-') && filename.includes('-');
+}
+
+/**
+ * Extract parts from a dash-formatted filename
+ * Parses: 'bmad-agent-bmm-pm.md' → { prefix: 'bmad', module: 'bmm', type: 'agents', name: 'pm' }
+ * Parses: 'bmad-bmm-correct-course.md' → { prefix: 'bmad', module: 'bmm', type: 'workflows', name: 'correct-course' }
+ * Parses: 'bmad-agent-brainstorming.md' → { prefix: 'bmad', module: 'core', type: 'agents', name: 'brainstorming' } (core agents)
+ * Parses: 'bmad-brainstorming.md' → { prefix: 'bmad', module: 'core', type: 'workflows', name: 'brainstorming' } (core workflows)
+ *
+ * @param {string} filename - Dash-formatted filename
+ * @returns {Object|null} Parsed parts or null if invalid format
+ */
+function parseDashName(filename) {
+  const withoutExt = filename.replace('.md', '');
+  const parts = withoutExt.split('-');
+
+  if (parts.length < 2 || parts[0] !== 'bmad') {
+    return null;
+  }
+
+  // Check if this is an agent file (has 'agent' as second part)
+  const isAgent = parts[1] === 'agent';
+
+  if (isAgent) {
+    // This is an agent file
+    // Format: bmad-agent-name (core) or bmad-agent-module-name
+    if (parts.length === 3) {
+      // Core agent: bmad-agent-name
+      return {
+        prefix: parts[0],
+        module: 'core',
+        type: 'agents',
+        name: parts[2],
+      };
+    } else {
+      // Module agent: bmad-agent-module-name
+      return {
+        prefix: parts[0],
+        module: parts[2],
+        type: 'agents',
+        name: parts.slice(3).join('-'),
+      };
+    }
+  }
+
+  // Not an agent file - must be a workflow/tool/task
+  // If only 2 parts (bmad-name), it's a core workflow/tool/task
+  if (parts.length === 2) {
+    return {
+      prefix: parts[0],
+      module: 'core',
+      type: 'workflows', // Default to workflows for non-agent core items
+      name: parts[1],
+    };
+  }
+
+  // Otherwise, it's a module workflow/tool/task (bmad-module-name)
+  return {
+    prefix: parts[0],
+    module: parts[1],
+    type: 'workflows', // Default to workflows for non-agent module items
+    name: parts.slice(2).join('-'),
+  };
+}
+
+// ============================================================================
+// LEGACY FUNCTIONS (underscore format) - kept for backward compatibility
+// ============================================================================
+
+/**
+ * Convert hierarchical path to flat underscore-separated name (LEGACY)
+ * @deprecated Use toDashName instead
+ */
+function toUnderscoreName(module, type, name) {
+  const isAgent = type === AGENT_SEGMENT;
+  if (module === 'core') {
+    return isAgent ? `bmad_agent_${name}.md` : `bmad_${name}.md`;
+  }
+  return isAgent ? `bmad_${module}_agent_${name}.md` : `bmad_${module}_${name}.md`;
+}
+
+/**
+ * Convert relative path to flat underscore-separated name (LEGACY)
+ * @deprecated Use toDashPath instead
+ */
+function toUnderscorePath(relativePath) {
+  // Strip common file extensions (same as toDashPath for consistency)
+  const withoutExt = relativePath.replace(/\.(md|yaml|yml|json|xml|toml)$/i, '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1];
+  const name = parts.slice(2).join('_');
+
+  return toUnderscoreName(module, type, name);
+}
+
+/**
+ * Create custom agent underscore name (LEGACY)
+ * @deprecated Use customAgentDashName instead
+ */
+function customAgentUnderscoreName(agentName) {
+  return `bmad_custom_${agentName}.md`;
+}
+
+/**
+ * Check if a filename uses underscore format (LEGACY)
+ * @deprecated Use isDashFormat instead
+ */
+function isUnderscoreFormat(filename) {
+  return filename.startsWith('bmad_') && filename.includes('_');
+}
+
+/**
+ * Extract parts from an underscore-formatted filename (LEGACY)
+ * @deprecated Use parseDashName instead
+ */
+function parseUnderscoreName(filename) {
+  const withoutExt = filename.replace('.md', '');
+  const parts = withoutExt.split('_');
+
+  if (parts.length < 2 || parts[0] !== 'bmad') {
+    return null;
+  }
+
+  const agentIndex = parts.indexOf('agent');
+
+  if (agentIndex !== -1) {
+    if (agentIndex === 1) {
+      return {
+        prefix: parts[0],
+        module: 'core',
+        type: 'agents',
+        name: parts.slice(agentIndex + 1).join('_'),
+      };
+    } else {
+      return {
+        prefix: parts[0],
+        module: parts[1],
+        type: 'agents',
+        name: parts.slice(agentIndex + 1).join('_'),
+      };
+    }
+  }
+
+  if (parts.length === 2) {
+    return {
+      prefix: parts[0],
+      module: 'core',
+      type: 'workflows',
+      name: parts[1],
+    };
+  }
+
+  return {
+    prefix: parts[0],
+    module: parts[1],
+    type: 'workflows',
+    name: parts.slice(2).join('_'),
+  };
+}
+
+// Backward compatibility aliases (colon format was same as underscore)
+const toColonName = toUnderscoreName;
+const toColonPath = toUnderscorePath;
+const customAgentColonName = customAgentUnderscoreName;
+const isColonFormat = isUnderscoreFormat;
+const parseColonName = parseUnderscoreName;
+
+module.exports = {
+  // New standard (dash-based)
+  toDashName,
+  toDashPath,
+  customAgentDashName,
+  isDashFormat,
+  parseDashName,
+
+  // Legacy (underscore-based) - kept for backward compatibility
+  toUnderscoreName,
+  toUnderscorePath,
+  customAgentUnderscoreName,
+  isUnderscoreFormat,
+  parseUnderscoreName,
+
+  // Backward compatibility aliases
+  toColonName,
+  toColonPath,
+  customAgentColonName,
+  isColonFormat,
+  parseColonName,
+
+  TYPE_SEGMENTS,
+  AGENT_SEGMENT,
+  BMAD_FOLDER_NAME,
+};

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

@@ -1,12 +1,95 @@
 const path = require('node:path');
 const fs = require('fs-extra');
 const csv = require('csv-parse/sync');
-const chalk = require('chalk');
+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
@@ -17,17 +100,13 @@ class TaskToolCommandGenerator {
     const tasks = await this.loadTaskManifest(bmadDir);
     const tools = await this.loadToolManifest(bmadDir);
 
-    // Filter to only standalone items
-    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-
     // 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 standaloneTasks) {
+    for (const task of tasks || []) {
       const moduleTasksDir = path.join(commandsDir, task.module, 'tasks');
       await fs.ensureDir(moduleTasksDir);
 
@@ -39,7 +118,7 @@ class TaskToolCommandGenerator {
     }
 
     // Generate command files for tools
-    for (const tool of standaloneTools) {
+    for (const tool of tools || []) {
       const moduleToolsDir = path.join(commandsDir, tool.module, 'tools');
       await fs.ensureDir(moduleToolsDir);
 
@@ -52,8 +131,8 @@ class TaskToolCommandGenerator {
 
     return {
       generated: generatedCount,
-      tasks: standaloneTasks.length,
-      tools: standaloneTools.length,
+      tasks: (tasks || []).length,
+      tools: (tools || []).length,
     };
   }
 
@@ -64,18 +143,45 @@ class TaskToolCommandGenerator {
     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.startsWith('bmad/')) {
-      itemPath = `{project-root}/${itemPath}`;
+    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("'", "''")}'
+disable-model-invocation: true
 ---
 
 # ${item.displayName || item.name}
 
-LOAD and execute the ${type} at: ${itemPath}
+Read the entire ${type} file at: ${itemPath}
 
 Follow all instructions in the ${type} file exactly as written.
 `;
@@ -85,7 +191,7 @@ Follow all instructions in the ${type} file exactly as written.
    * Load task manifest CSV
    */
   async loadTaskManifest(bmadDir) {
-    const manifestPath = path.join(bmadDir, '_cfg', 'task-manifest.csv');
+    const manifestPath = path.join(bmadDir, '_config', 'task-manifest.csv');
 
     if (!(await fs.pathExists(manifestPath))) {
       return null;
@@ -102,7 +208,7 @@ Follow all instructions in the ${type} file exactly as written.
    * Load tool manifest CSV
    */
   async loadToolManifest(bmadDir) {
-    const manifestPath = path.join(bmadDir, '_cfg', 'tool-manifest.csv');
+    const manifestPath = path.join(bmadDir, '_config', 'tool-manifest.csv');
 
     if (!(await fs.pathExists(manifestPath))) {
       return null;
@@ -114,6 +220,148 @@ Follow all instructions in the ${type} file exactly as written.
       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 };