@zeyue0329/xiaoma-cli 1.0.49 → 6.0.0-alpha.13

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

@@ -0,0 +1,324 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * Roo IDE setup handler
+ * Creates custom modes in .roomodes file
+ */
+class RooSetup extends BaseIdeSetup {
+  constructor() {
+    super('roo', 'Roo Code');
+    this.configFile = '.roomodes';
+    this.defaultPermissions = {
+      dev: {
+        description: 'Development files',
+        fileRegex: String.raw`.*\.(js|jsx|ts|tsx|py|java|cpp|c|h|cs|go|rs|php|rb|swift)$`,
+      },
+      config: {
+        description: 'Configuration files',
+        fileRegex: String.raw`.*\.(json|yaml|yml|toml|xml|ini|env|config)$`,
+      },
+      docs: {
+        description: 'Documentation files',
+        fileRegex: String.raw`.*\.(md|mdx|rst|txt|doc|docx)$`,
+      },
+      styles: {
+        description: 'Style and design files',
+        fileRegex: String.raw`.*\.(css|scss|sass|less|stylus)$`,
+      },
+      all: {
+        description: 'All files',
+        fileRegex: '.*',
+      },
+    };
+  }
+
+  /**
+   * Setup Roo IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, xiaomaDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Check for existing .roomodes file
+    const roomodesPath = path.join(projectDir, this.configFile);
+    let existingModes = [];
+    let existingContent = '';
+
+    if (await this.pathExists(roomodesPath)) {
+      existingContent = await this.readFile(roomodesPath);
+      // Parse existing modes to avoid duplicates
+      const modeMatches = existingContent.matchAll(/- slug: ([\w-]+)/g);
+      for (const match of modeMatches) {
+        existingModes.push(match[1]);
+      }
+      console.log(chalk.yellow(`Found existing .roomodes file with ${existingModes.length} modes`));
+    }
+
+    // Generate agent launchers (though Roo will reference the actual .xiaoma agents)
+    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, options.selectedModules || []);
+
+    // Always use 'all' permissions - users can customize in .roomodes file
+    const permissionChoice = 'all';
+
+    // Create modes content
+    let newModesContent = '';
+    let addedCount = 0;
+    let skippedCount = 0;
+
+    for (const artifact of agentArtifacts) {
+      const slug = `xiaoma-${artifact.module}-${artifact.name}`;
+
+      // Skip if already exists
+      if (existingModes.includes(slug)) {
+        console.log(chalk.dim(`  Skipping ${slug} - already exists`));
+        skippedCount++;
+        continue;
+      }
+
+      // Read the actual agent file from .xiaoma for metadata extraction
+      const agentPath = path.join(xiaomaDir, artifact.module, 'agents', `${artifact.name}.md`);
+      const content = await this.readFile(agentPath);
+
+      // Create mode entry that references the actual .xiaoma agent
+      const modeEntry = await this.createModeEntry(
+        { module: artifact.module, name: artifact.name, path: agentPath },
+        content,
+        permissionChoice,
+        projectDir,
+      );
+
+      newModesContent += modeEntry;
+      addedCount++;
+      console.log(chalk.green(`  ✓ Added mode: ${slug}`));
+    }
+
+    // Build final content
+    let finalContent = '';
+    if (existingContent) {
+      // Append to existing content
+      finalContent = existingContent.trim() + '\n' + newModesContent;
+    } else {
+      // Create new .roomodes file
+      finalContent = 'customModes:\n' + newModesContent;
+    }
+
+    // Write .roomodes file
+    await this.writeFile(roomodesPath, finalContent);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${addedCount} modes added`));
+    if (skippedCount > 0) {
+      console.log(chalk.dim(`  - ${skippedCount} modes skipped (already exist)`));
+    }
+    console.log(chalk.dim(`  - Configuration file: ${this.configFile}`));
+    console.log(chalk.dim(`  - Permission level: all (unrestricted)`));
+    console.log(chalk.yellow(`\n  💡 Tip: Edit ${this.configFile} to customize file permissions per agent`));
+    console.log(chalk.dim(`  Modes will be available when you open this project in Roo Code`));
+
+    return {
+      success: true,
+      modes: addedCount,
+      skipped: skippedCount,
+    };
+  }
+
+  /**
+   * Create a mode entry for an agent
+   */
+  async createModeEntry(agent, content, permissionChoice, projectDir) {
+    // Extract metadata from agent content
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    const iconMatch = content.match(/icon="([^"]+)"/);
+    const icon = iconMatch ? iconMatch[1] : '🤖';
+
+    const whenToUseMatch = content.match(/whenToUse="([^"]+)"/);
+    const whenToUse = whenToUseMatch ? whenToUseMatch[1] : `Use for ${title} tasks`;
+
+    // Get the activation header from central template
+    const activationHeader = await this.getAgentCommandHeader();
+
+    const roleDefinitionMatch = content.match(/roleDefinition="([^"]+)"/);
+    const roleDefinition = roleDefinitionMatch
+      ? roleDefinitionMatch[1]
+      : `You are a ${title} specializing in ${title.toLowerCase()} tasks and responsibilities.`;
+
+    // Get relative path
+    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
+
+    // Determine permissions
+    const permissions = this.getPermissionsForAgent(agent, permissionChoice);
+
+    // Build mode entry
+    const slug = `xiaoma-${agent.module}-${agent.name}`;
+    let modeEntry = ` - slug: ${slug}\n`;
+    modeEntry += `   name: '${icon} ${title}'\n`;
+
+    if (permissions && permissions.description) {
+      modeEntry += `   description: '${permissions.description}'\n`;
+    }
+
+    modeEntry += `   roleDefinition: ${roleDefinition}\n`;
+    modeEntry += `   whenToUse: ${whenToUse}\n`;
+    modeEntry += `   customInstructions: ${activationHeader} Read the full YAML from ${relativePath} start activation to alter your state of being follow startup section instructions stay in this being until told to exit this mode\n`;
+    modeEntry += `   groups:\n`;
+    modeEntry += `    - read\n`;
+
+    if (permissions && permissions.fileRegex) {
+      modeEntry += `    - - edit\n`;
+      modeEntry += `      - fileRegex: ${permissions.fileRegex}\n`;
+      modeEntry += `        description: ${permissions.description}\n`;
+    } else {
+      modeEntry += `    - edit\n`;
+    }
+
+    return modeEntry;
+  }
+
+  /**
+   * Get permissions configuration for an agent
+   */
+  getPermissionsForAgent(agent, permissionChoice) {
+    if (permissionChoice === 'custom') {
+      // Custom logic based on agent name/module
+      if (agent.name.includes('dev') || agent.name.includes('code')) {
+        return this.defaultPermissions.dev;
+      } else if (agent.name.includes('doc') || agent.name.includes('write')) {
+        return this.defaultPermissions.docs;
+      } else if (agent.name.includes('config') || agent.name.includes('setup')) {
+        return this.defaultPermissions.config;
+      } else if (agent.name.includes('style') || agent.name.includes('css')) {
+        return this.defaultPermissions.styles;
+      }
+      // Default to all for custom agents
+      return this.defaultPermissions.all;
+    }
+
+    return this.defaultPermissions[permissionChoice] || null;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Roo configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const roomodesPath = path.join(projectDir, this.configFile);
+
+    if (await fs.pathExists(roomodesPath)) {
+      const content = await fs.readFile(roomodesPath, 'utf8');
+
+      // Remove XIAOMA modes only
+      const lines = content.split('\n');
+      const filteredLines = [];
+      let skipMode = false;
+      let removedCount = 0;
+
+      for (const line of lines) {
+        if (/^\s*- slug: xiaoma-/.test(line)) {
+          skipMode = true;
+          removedCount++;
+        } else if (skipMode && /^\s*- slug: /.test(line)) {
+          skipMode = false;
+        }
+
+        if (!skipMode) {
+          filteredLines.push(line);
+        }
+      }
+
+      // Write back filtered content
+      await fs.writeFile(roomodesPath, filteredLines.join('\n'));
+      console.log(chalk.dim(`Removed ${removedCount} XIAOMA modes from .roomodes`));
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for Roo
+   * @param {string} projectDir - Project directory
+   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
+   * @param {string} agentPath - Path to compiled agent (relative to project root)
+   * @param {Object} metadata - Agent metadata
+   * @returns {Object} Installation result
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    const roomodesPath = path.join(projectDir, this.configFile);
+    let existingContent = '';
+
+    // Read existing .roomodes file
+    if (await this.pathExists(roomodesPath)) {
+      existingContent = await this.readFile(roomodesPath);
+    }
+
+    // Create custom agent mode entry
+    const slug = `xiaoma-custom-${agentName.toLowerCase()}`;
+    const modeEntry = ` - slug: ${slug}
+   name: 'XIAOMA Custom: ${agentName}'
+   description: |
+    Custom XIAOMA agent: ${agentName}
+
+    **⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
+
+    This is a launcher for the custom XIAOMA agent "${agentName}". The agent will follow the persona and instructions from the main agent file.
+   prompt: |
+    @${agentPath}
+   always: false
+   permissions: all
+`;
+
+    // Check if mode already exists
+    if (existingContent.includes(slug)) {
+      return {
+        ide: 'roo',
+        path: this.configFile,
+        command: agentName,
+        type: 'custom-agent-launcher',
+        alreadyExists: true,
+      };
+    }
+
+    // Build final content
+    let finalContent = '';
+    if (existingContent) {
+      // Find customModes section or add it
+      if (existingContent.includes('customModes:')) {
+        // Append to existing customModes
+        finalContent = existingContent + modeEntry;
+      } else {
+        // Add customModes section
+        finalContent = existingContent.trim() + '\n\ncustomModes:\n' + modeEntry;
+      }
+    } else {
+      // Create new .roomodes file with customModes
+      finalContent = 'customModes:\n' + modeEntry;
+    }
+
+    // Write .roomodes file
+    await this.writeFile(roomodesPath, finalContent);
+
+    return {
+      ide: 'roo',
+      path: this.configFile,
+      command: slug,
+      type: 'custom-agent-launcher',
+    };
+  }
+}
+
+module.exports = { RooSetup };

package/tools/cli/installers/lib/ide/rovo-dev.js

@@ -0,0 +1,290 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { BaseIdeSetup } = require('./_base-ide');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
+
+/**
+ * Rovo Dev IDE setup handler
+ *
+ * Installs XIAOMA agents as Rovo Dev subagents in .rovodev/subagents/
+ * Installs workflows and tasks/tools as reference guides in .rovodev/
+ * Rovo Dev automatically discovers agents and integrates with XIAOMA like other IDEs
+ */
+class RovoDevSetup extends BaseIdeSetup {
+  constructor() {
+    super('rovo-dev', 'Atlassian Rovo Dev', true); // preferred IDE
+    this.configDir = '.rovodev';
+    this.subagentsDir = 'subagents';
+    this.workflowsDir = 'workflows';
+    this.referencesDir = 'references';
+  }
+
+  /**
+   * Cleanup old XIAOMA installation before reinstalling
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const rovoDevDir = path.join(projectDir, this.configDir);
+
+    if (!(await fs.pathExists(rovoDevDir))) {
+      return;
+    }
+
+    // Clean XIAOMA agents from subagents directory
+    const subagentsDir = path.join(rovoDevDir, this.subagentsDir);
+    if (await fs.pathExists(subagentsDir)) {
+      const entries = await fs.readdir(subagentsDir);
+      const xiaomaFiles = entries.filter((file) => file.startsWith('xiaoma-') && file.endsWith('.md'));
+
+      for (const file of xiaomaFiles) {
+        await fs.remove(path.join(subagentsDir, file));
+      }
+    }
+
+    // Clean XIAOMA workflows from workflows directory
+    const workflowsDir = path.join(rovoDevDir, this.workflowsDir);
+    if (await fs.pathExists(workflowsDir)) {
+      const entries = await fs.readdir(workflowsDir);
+      const xiaomaFiles = entries.filter((file) => file.startsWith('xiaoma-') && file.endsWith('.md'));
+
+      for (const file of xiaomaFiles) {
+        await fs.remove(path.join(workflowsDir, file));
+      }
+    }
+
+    // Clean XIAOMA tasks/tools from references directory
+    const referencesDir = path.join(rovoDevDir, this.referencesDir);
+    if (await fs.pathExists(referencesDir)) {
+      const entries = await fs.readdir(referencesDir);
+      const xiaomaFiles = entries.filter((file) => file.startsWith('xiaoma-') && file.endsWith('.md'));
+
+      for (const file of xiaomaFiles) {
+        await fs.remove(path.join(referencesDir, file));
+      }
+    }
+  }
+
+  /**
+   * Setup Rovo Dev configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, xiaomaDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Clean up old XIAOMA installation first
+    await this.cleanup(projectDir);
+
+    // Create .rovodev directory structure
+    const rovoDevDir = path.join(projectDir, this.configDir);
+    const subagentsDir = path.join(rovoDevDir, this.subagentsDir);
+    const workflowsDir = path.join(rovoDevDir, this.workflowsDir);
+    const referencesDir = path.join(rovoDevDir, this.referencesDir);
+
+    await this.ensureDir(subagentsDir);
+    await this.ensureDir(workflowsDir);
+    await this.ensureDir(referencesDir);
+
+    // Generate and install agents
+    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, options.selectedModules || []);
+
+    let agentCount = 0;
+    for (const artifact of agentArtifacts) {
+      const subagentFilename = `xiaoma-${artifact.module}-${artifact.name}.md`;
+      const targetPath = path.join(subagentsDir, subagentFilename);
+      const subagentContent = this.convertToRovoDevSubagent(artifact.content, artifact.name, artifact.module);
+      await this.writeFile(targetPath, subagentContent);
+      agentCount++;
+    }
+
+    // Generate and install workflows
+    const workflowGen = new WorkflowCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGen.collectWorkflowArtifacts(xiaomaDir);
+
+    let workflowCount = 0;
+    for (const artifact of workflowArtifacts) {
+      if (artifact.type === 'workflow-command') {
+        const workflowFilename = path.basename(artifact.relativePath);
+        const targetPath = path.join(workflowsDir, workflowFilename);
+        await this.writeFile(targetPath, artifact.content);
+        workflowCount++;
+      }
+    }
+
+    // Generate and install tasks and tools
+    const taskToolGen = new TaskToolCommandGenerator();
+    const { tasks: taskCount, tools: toolCount } = await this.generateTaskToolReferences(xiaomaDir, referencesDir, taskToolGen);
+
+    // Summary output
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents installed to .rovodev/subagents/`));
+    if (workflowCount > 0) {
+      console.log(chalk.dim(`  - ${workflowCount} workflows installed to .rovodev/workflows/`));
+    }
+    if (taskCount + toolCount > 0) {
+      console.log(
+        chalk.dim(`  - ${taskCount + toolCount} tasks/tools installed to .rovodev/references/ (${taskCount} tasks, ${toolCount} tools)`),
+      );
+    }
+    console.log(chalk.yellow(`\n  Note: Agents are automatically discovered by Rovo Dev`));
+    console.log(chalk.dim(`  - Access agents by typing @ in Rovo Dev to see available options`));
+    console.log(chalk.dim(`  - Workflows and references are available in .rovodev/ directory`));
+
+    return {
+      success: true,
+      agents: agentCount,
+      workflows: workflowCount,
+      tasks: taskCount,
+      tools: toolCount,
+    };
+  }
+
+  /**
+   * Generate task and tool reference guides
+   * @param {string} xiaomaDir - XIAOMA directory
+   * @param {string} referencesDir - References directory
+   * @param {TaskToolCommandGenerator} taskToolGen - Generator instance
+   */
+  async generateTaskToolReferences(xiaomaDir, referencesDir, taskToolGen) {
+    const tasks = await taskToolGen.loadTaskManifest(xiaomaDir);
+    const tools = await taskToolGen.loadToolManifest(xiaomaDir);
+
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    let taskCount = 0;
+    for (const task of standaloneTasks) {
+      const commandContent = taskToolGen.generateCommandContent(task, 'task');
+      const targetPath = path.join(referencesDir, `xiaoma-task-${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+      taskCount++;
+    }
+
+    let toolCount = 0;
+    for (const tool of standaloneTools) {
+      const commandContent = taskToolGen.generateCommandContent(tool, 'tool');
+      const targetPath = path.join(referencesDir, `xiaoma-tool-${tool.module}-${tool.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+      toolCount++;
+    }
+
+    return { tasks: taskCount, tools: toolCount };
+  }
+
+  /**
+   * Convert XIAOMA agent launcher to Rovo Dev subagent format
+   *
+   * Rovo Dev subagents use Markdown files with YAML frontmatter containing:
+   * - name: Unique identifier for the subagent
+   * - description: One-line description of the subagent's purpose
+   * - tools: Array of tools the subagent can use (optional)
+   * - model: Specific model for this subagent (optional)
+   * - load_memory: Whether to load memory files (optional, defaults to true)
+   *
+   * @param {string} launcherContent - Original agent launcher content
+   * @param {string} agentName - Name of the agent
+   * @param {string} moduleName - Name of the module
+   * @returns {string} Rovo Dev subagent-formatted content
+   */
+  convertToRovoDevSubagent(launcherContent, agentName, moduleName) {
+    // Extract metadata from the launcher XML
+    const titleMatch = launcherContent.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agentName);
+
+    const descriptionMatch = launcherContent.match(/description="([^"]+)"/);
+    const description = descriptionMatch ? descriptionMatch[1] : `XIAOMA agent: ${title}`;
+
+    const roleDefinitionMatch = launcherContent.match(/roleDefinition="([^"]+)"/);
+    const roleDefinition = roleDefinitionMatch ? roleDefinitionMatch[1] : `You are a specialized agent for ${title.toLowerCase()} tasks.`;
+
+    // Extract the main system prompt from the launcher (content after closing tags)
+    let systemPrompt = roleDefinition;
+
+    // Try to extract additional instructions from the launcher content
+    const instructionsMatch = launcherContent.match(/<instructions>([\s\S]*?)<\/instructions>/);
+    if (instructionsMatch) {
+      systemPrompt += '\n\n' + instructionsMatch[1].trim();
+    }
+
+    // Build YAML frontmatter for Rovo Dev subagent
+    const frontmatter = {
+      name: `xiaoma-${moduleName}-${agentName}`,
+      description: description,
+      // Note: tools and model can be added by users in their .rovodev/subagents/*.md files
+      // We don't enforce specific tools since XIAOMA agents are flexible
+    };
+
+    // Create YAML frontmatter string with proper quoting for special characters
+    let yamlContent = '---\n';
+    yamlContent += `name: ${frontmatter.name}\n`;
+    // Quote description to handle colons and other special characters in YAML
+    yamlContent += `description: "${frontmatter.description.replaceAll('"', String.raw`\"`)}"\n`;
+    yamlContent += '---\n';
+
+    // Combine frontmatter with system prompt
+    const subagentContent = yamlContent + systemPrompt;
+
+    return subagentContent;
+  }
+
+  /**
+   * Detect whether Rovo Dev is already configured in the project
+   * @param {string} projectDir - Project directory
+   * @returns {boolean}
+   */
+  async detect(projectDir) {
+    const rovoDevDir = path.join(projectDir, this.configDir);
+
+    if (!(await fs.pathExists(rovoDevDir))) {
+      return false;
+    }
+
+    // Check for XIAOMA agents in subagents directory
+    const subagentsDir = path.join(rovoDevDir, this.subagentsDir);
+    if (await fs.pathExists(subagentsDir)) {
+      try {
+        const entries = await fs.readdir(subagentsDir);
+        if (entries.some((entry) => entry.startsWith('xiaoma-') && entry.endsWith('.md'))) {
+          return true;
+        }
+      } catch {
+        // Continue checking other directories
+      }
+    }
+
+    // Check for XIAOMA workflows in workflows directory
+    const workflowsDir = path.join(rovoDevDir, this.workflowsDir);
+    if (await fs.pathExists(workflowsDir)) {
+      try {
+        const entries = await fs.readdir(workflowsDir);
+        if (entries.some((entry) => entry.startsWith('xiaoma-') && entry.endsWith('.md'))) {
+          return true;
+        }
+      } catch {
+        // Continue checking other directories
+      }
+    }
+
+    // Check for XIAOMA tasks/tools in references directory
+    const referencesDir = path.join(rovoDevDir, this.referencesDir);
+    if (await fs.pathExists(referencesDir)) {
+      try {
+        const entries = await fs.readdir(referencesDir);
+        if (entries.some((entry) => entry.startsWith('xiaoma-') && entry.endsWith('.md'))) {
+          return true;
+        }
+      } catch {
+        // Continue
+      }
+    }
+
+    return false;
+  }
+}
+
+module.exports = { RovoDevSetup };

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

@@ -0,0 +1,90 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+
+/**
+ * Generates launcher command files for each agent
+ * Similar to WorkflowCommandGenerator but for agents
+ */
+class AgentCommandGenerator {
+  constructor(xiaomaFolderName = 'xiaoma') {
+    this.templatePath = path.join(__dirname, '../templates/agent-command-template.md');
+    this.xiaomaFolderName = xiaomaFolderName;
+  }
+
+  /**
+   * Collect agent artifacts for IDE installation
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {Array} selectedModules - Modules to include
+   * @returns {Object} Artifacts array with metadata
+   */
+  async collectAgentArtifacts(xiaomaDir, selectedModules = []) {
+    const { getAgentsFromBmad } = require('./xiaoma-artifacts');
+
+    // Get agents from INSTALLED xiaoma/ directory
+    const agents = await getAgentsFromBmad(xiaomaDir, selectedModules);
+
+    const artifacts = [];
+
+    for (const agent of agents) {
+      const launcherContent = await this.generateLauncherContent(agent);
+      artifacts.push({
+        type: 'agent-launcher',
+        module: agent.module,
+        name: agent.name,
+        relativePath: path.join(agent.module, 'agents', `${agent.name}.md`),
+        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
+    return template
+      .replaceAll('{{name}}', agent.name)
+      .replaceAll('{{module}}', agent.module)
+      .replaceAll('{{description}}', agent.description || `${agent.name} agent`)
+      .replaceAll('{xiaoma_folder}', this.xiaomaFolderName);
+  }
+
+  /**
+   * 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;
+  }
+}
+
+module.exports = { AgentCommandGenerator };