bmad-elsabro 1.0.0

package/tools/cli/installers/lib/ide/platform-codes.yaml

@@ -0,0 +1,227 @@
+# BMAD Platform Codes Configuration
+# Central configuration for all platform/IDE codes used in the BMAD system
+#
+# This file defines:
+# 1. Platform metadata (name, preferred status, category, description)
+# 2. Installer configuration (target directories, templates, artifact types)
+#
+# Format:
+#   code: Platform identifier used internally
+#   name: Display name shown to users
+#   preferred: Whether this platform is shown as a recommended option on install
+#   category: Type of platform (ide, cli, tool, service)
+#   description: Brief description of the platform
+#   installer: Installation configuration (optional - omit for custom installers)
+
+platforms:
+  antigravity:
+    name: "Google Antigravity"
+    preferred: false
+    category: ide
+    description: "Google's AI development environment"
+    installer:
+      target_dir: .agent/workflows
+      template_type: antigravity
+
+  auggie:
+    name: "Auggie"
+    preferred: false
+    category: cli
+    description: "AI development tool"
+    installer:
+      target_dir: .augment/commands
+      template_type: default
+
+  claude-code:
+    name: "Claude Code"
+    preferred: true
+    category: cli
+    description: "Anthropic's official CLI for Claude"
+    installer:
+      target_dir: .claude/commands
+      template_type: default
+
+  cline:
+    name: "Cline"
+    preferred: false
+    category: ide
+    description: "AI coding assistant"
+    installer:
+      target_dir: .clinerules/workflows
+      template_type: windsurf
+
+  codex:
+    name: "Codex"
+    preferred: false
+    category: cli
+    description: "OpenAI Codex integration"
+    # No installer config - uses custom codex.js
+
+  crush:
+    name: "Crush"
+    preferred: false
+    category: ide
+    description: "AI development assistant"
+    installer:
+      target_dir: .crush/commands
+      template_type: default
+
+  cursor:
+    name: "Cursor"
+    preferred: true
+    category: ide
+    description: "AI-first code editor"
+    installer:
+      target_dir: .cursor/commands
+      template_type: default
+
+  gemini:
+    name: "Gemini CLI"
+    preferred: false
+    category: cli
+    description: "Google's CLI for Gemini"
+    installer:
+      target_dir: .gemini/commands
+      template_type: gemini
+
+  github-copilot:
+    name: "GitHub Copilot"
+    preferred: false
+    category: ide
+    description: "GitHub's AI pair programmer"
+    installer:
+      targets:
+        - target_dir: .github/agents
+          template_type: copilot_agents
+          artifact_types: [agents]
+        - target_dir: .vscode
+          template_type: vscode_settings
+          artifact_types: []
+
+  iflow:
+    name: "iFlow"
+    preferred: false
+    category: ide
+    description: "AI workflow automation"
+    installer:
+      target_dir: .iflow/commands
+      template_type: default
+
+  kilo:
+    name: "KiloCoder"
+    preferred: false
+    category: ide
+    description: "AI coding platform"
+    # No installer config - uses custom kilo.js (creates .kilocodemodes file)
+
+  kiro-cli:
+    name: "Kiro CLI"
+    preferred: false
+    category: cli
+    description: "Kiro command-line interface"
+    # No installer config - uses custom kiro-cli.js (YAML→JSON conversion)
+
+  opencode:
+    name: "OpenCode"
+    preferred: false
+    category: ide
+    description: "OpenCode terminal coding assistant"
+    installer:
+      target_dir: .opencode/command
+      template_type: opencode
+
+  qwen:
+    name: "QwenCoder"
+    preferred: false
+    category: ide
+    description: "Qwen AI coding assistant"
+    installer:
+      target_dir: .qwen/commands
+      template_type: default
+
+  roo:
+    name: "Roo Cline"
+    preferred: false
+    category: ide
+    description: "Enhanced Cline fork"
+    installer:
+      target_dir: .roo/commands
+      template_type: default
+
+  rovo-dev:
+    name: "Rovo Dev"
+    preferred: false
+    category: ide
+    description: "Atlassian's Rovo development environment"
+    installer:
+      target_dir: .rovodev/workflows
+      template_type: rovodev
+
+  trae:
+    name: "Trae"
+    preferred: false
+    category: ide
+    description: "AI coding tool"
+    installer:
+      target_dir: .trae/rules
+      template_type: trae
+
+  windsurf:
+    name: "Windsurf"
+    preferred: true
+    category: ide
+    description: "AI-powered IDE with cascade flows"
+    installer:
+      target_dir: .windsurf/workflows
+      template_type: windsurf
+
+# ============================================================================
+# Installer Config Schema
+# ============================================================================
+#
+# installer:
+#   target_dir: string                    # Directory where artifacts are installed
+#   template_type: string                 # Default template type to use
+#   header_template: string (optional)    # Override for header/frontmatter template
+#   body_template: string (optional)      # Override for body/content template
+#   targets: array (optional)             # For multi-target installations
+#     - target_dir: string
+#       template_type: string
+#       artifact_types: [agents, workflows, tasks, tools]
+#   artifact_types: array (optional)      # Filter which artifacts to install (default: all)
+#   skip_existing: boolean (optional)     # Skip files that already exist (default: false)
+
+# ============================================================================
+# Platform Categories
+# ============================================================================
+
+categories:
+  ide:
+    name: "Integrated Development Environment"
+    description: "Full-featured code editors with AI assistance"
+
+  cli:
+    name: "Command Line Interface"
+    description: "Terminal-based tools"
+
+  tool:
+    name: "Development Tool"
+    description: "Standalone development utilities"
+
+  service:
+    name: "Cloud Service"
+    description: "Cloud-based development platforms"
+
+  extension:
+    name: "Editor Extension"
+    description: "Plugins for existing editors"
+
+# ============================================================================
+# Naming Conventions and Rules
+# ============================================================================
+
+conventions:
+  code_format: "lowercase-kebab-case"
+  name_format: "Title Case"
+  max_code_length: 20
+  allowed_characters: "a-z0-9-"

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

@@ -0,0 +1,181 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { toColonPath, toDashPath, customAgentColonName, customAgentDashName } = require('./path-utils');
+
+/**
+ * Generates launcher command files for each agent
+ * Similar to WorkflowCommandGenerator but for agents
+ */
+class AgentCommandGenerator {
+  constructor(bmadFolderName = 'bmad') {
+    this.templatePath = path.join(__dirname, '../templates/agent-command-template.md');
+    this.bmadFolderName = bmadFolderName;
+  }
+
+  /**
+   * Collect agent artifacts for IDE installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Array} selectedModules - Modules to include
+   * @returns {Object} Artifacts array with metadata
+   */
+  async collectAgentArtifacts(bmadDir, selectedModules = []) {
+    const { getAgentsFromBmad } = require('./bmad-artifacts');
+
+    // Get agents from INSTALLED bmad/ directory
+    const agents = await getAgentsFromBmad(bmadDir, selectedModules);
+
+    const artifacts = [];
+
+    for (const agent of agents) {
+      const launcherContent = await this.generateLauncherContent(agent);
+      // Use relativePath if available (for nested agents), otherwise just name with .md
+      const agentPathInModule = agent.relativePath || `${agent.name}.md`;
+      // Calculate the relative agent path (e.g., bmm/agents/pm.md)
+      let agentRelPath = agent.path || '';
+      // Normalize path separators for cross-platform compatibility
+      agentRelPath = agentRelPath.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 (agentRelPath.includes('_bmad/')) {
+        const parts = agentRelPath.split(/_bmad\//);
+        if (parts.length > 1) {
+          agentRelPath = parts.slice(1).join('/');
+        }
+      }
+      artifacts.push({
+        type: 'agent-launcher',
+        name: agent.name,
+        description: agent.description || `${agent.name} agent`,
+        module: agent.module,
+        relativePath: path.join(agent.module, 'agents', agentPathInModule), // For command filename
+        agentPath: agentRelPath, // Relative path to actual agent file
+        content: launcherContent,
+        sourcePath: agent.path,
+      });
+    }
+
+    return {
+      artifacts,
+      counts: {
+        agents: agents.length,
+      },
+    };
+  }
+
+  /**
+   * Generate launcher content for an agent
+   * @param {Object} agent - Agent metadata
+   * @returns {string} Launcher file content
+   */
+  async generateLauncherContent(agent) {
+    // Load the template
+    const template = await fs.readFile(this.templatePath, 'utf8');
+
+    // Replace template variables
+    // Use relativePath if available (for nested agents), otherwise just name with .md
+    const agentPathInModule = agent.relativePath || `${agent.name}.md`;
+    return template
+      .replaceAll('{{name}}', agent.name)
+      .replaceAll('{{module}}', agent.module)
+      .replaceAll('{{path}}', agentPathInModule)
+      .replaceAll('{{description}}', agent.description || `${agent.name} agent`)
+      .replaceAll('_bmad', this.bmadFolderName)
+      .replaceAll('_bmad', '_bmad');
+  }
+
+  /**
+   * Write agent launcher artifacts to IDE commands directory
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Agent launcher artifacts
+   * @returns {number} Count of launchers written
+   */
+  async writeAgentLaunchers(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'agent-launcher') {
+        const moduleAgentsDir = path.join(baseCommandsDir, artifact.module, 'agents');
+        await fs.ensureDir(moduleAgentsDir);
+
+        const launcherPath = path.join(moduleAgentsDir, `${artifact.name}.md`);
+        await fs.writeFile(launcherPath, artifact.content);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+
+  /**
+   * Write agent launcher artifacts using underscore format (Windows-compatible)
+   * Creates flat files like: bmad_bmm_pm.md
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Agent launcher artifacts
+   * @returns {number} Count of launchers written
+   */
+  async writeColonArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'agent-launcher') {
+        // Convert relativePath to underscore format: bmm/agents/pm.md → bmad_bmm_pm.md
+        const flatName = toColonPath(artifact.relativePath);
+        const launcherPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(launcherPath));
+        await fs.writeFile(launcherPath, artifact.content);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+
+  /**
+   * Write agent launcher artifacts using dash format (NEW STANDARD)
+   * Creates flat files like: bmad-agent-bmm-pm.md
+   *
+   * The bmad-agent- prefix distinguishes agents from workflows/tasks/tools.
+   *
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {Array} artifacts - Agent launcher artifacts
+   * @returns {number} Count of launchers written
+   */
+  async writeDashArtifacts(baseCommandsDir, artifacts) {
+    let writtenCount = 0;
+
+    for (const artifact of artifacts) {
+      if (artifact.type === 'agent-launcher') {
+        // Convert relativePath to dash format: bmm/agents/pm.md → bmad-agent-bmm-pm.md
+        const flatName = toDashPath(artifact.relativePath);
+        const launcherPath = path.join(baseCommandsDir, flatName);
+        await fs.ensureDir(path.dirname(launcherPath));
+        await fs.writeFile(launcherPath, artifact.content);
+        writtenCount++;
+      }
+    }
+
+    return writtenCount;
+  }
+
+  /**
+   * Get the custom agent name in underscore format (Windows-compatible)
+   * @param {string} agentName - Custom agent name
+   * @returns {string} Underscore-formatted filename
+   */
+  getCustomAgentColonName(agentName) {
+    return customAgentColonName(agentName);
+  }
+
+  /**
+   * Get the custom agent name in underscore format (Windows-compatible)
+   * @param {string} agentName - Custom agent name
+   * @returns {string} Underscore-formatted filename
+   */
+  getCustomAgentDashName(agentName) {
+    return customAgentDashName(agentName);
+  }
+}
+
+module.exports = { AgentCommandGenerator };

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

@@ -0,0 +1,163 @@
+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, relativePath = '') {
+  const agents = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return agents;
+  }
+
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    // Skip if entry.name is undefined or not a string
+    if (!entry.name || typeof entry.name !== 'string') {
+      continue;
+    }
+
+    const fullPath = path.join(dirPath, entry.name);
+    const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      // Recurse into subdirectories
+      const subDirAgents = await getAgentsFromDir(fullPath, moduleName, newRelativePath);
+      agents.push(...subDirAgents);
+    } else if (entry.name.endsWith('.md')) {
+      // Skip README files and other non-agent files
+      if (entry.name.toLowerCase() === 'readme.md' || entry.name.toLowerCase().startsWith('readme-')) {
+        continue;
+      }
+
+      if (entry.name.includes('.customize.')) {
+        continue;
+      }
+
+      const content = await fs.readFile(fullPath, 'utf8');
+
+      if (content.includes('localskip="true"')) {
+        continue;
+      }
+
+      // Only include files that have agent-specific content (compiled agents have <agent> tag)
+      if (!content.includes('<agent')) {
+        continue;
+      }
+
+      agents.push({
+        path: fullPath,
+        name: entry.name.replace('.md', ''),
+        module: moduleName,
+        relativePath: newRelativePath, // Keep the .md extension for the full path
+      });
+    }
+  }
+
+  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,136 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('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.parse(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) {
+    // Use forward slashes for glob pattern (works on both Windows and Unix)
+    // Convert backslashes to forward slashes for glob compatibility
+    const normalizedSourceDir = sourceDir.replaceAll('\\', '/');
+    const pattern = `${normalizedSourceDir}/**/${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,
+};