@zeyue0329/xiaoma-cli 1.0.49 → 1.6.4

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

@@ -0,0 +1,257 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+const { BaseIdeSetup } = require('./_base-ide');
+const prompts = require('../../../lib/prompts');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
+const { toDashPath } = require('./shared/path-utils');
+
+/**
+ * Rovo Dev IDE setup handler
+ *
+ * Custom installer that writes .md workflow files to .rovodev/workflows/
+ * and generates .rovodev/prompts.yml to register them with Rovo Dev's /prompts feature.
+ *
+ * prompts.yml format (per Rovo Dev docs):
+ *   prompts:
+ *     - name: xiaoma-xmc-create-prd
+ *       description: "PRD workflow..."
+ *       content_file: workflows/xiaoma-xmc-create-prd.md
+ */
+class RovoDevSetup extends BaseIdeSetup {
+  constructor() {
+    super('rovo-dev', 'Rovo Dev', false);
+    this.rovoDir = '.rovodev';
+    this.workflowsDir = 'workflows';
+    this.promptsFile = 'prompts.yml';
+  }
+
+  /**
+   * Setup Rovo Dev configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {Object} options - Setup options
+   * @returns {Promise<Object>} Setup result with { success, results: { agents, workflows, tasks, tools } }
+   */
+  async setup(projectDir, xiaomaDir, options = {}) {
+    if (!options.silent) await prompts.log.info(`Setting up ${this.name}...`);
+
+    // Clean up any old XIAOMA installation first
+    await this.cleanup(projectDir, options);
+
+    const workflowsPath = path.join(projectDir, this.rovoDir, this.workflowsDir);
+    await this.ensureDir(workflowsPath);
+
+    const selectedModules = options.selectedModules || [];
+    const writtenFiles = [];
+
+    // Generate and write agent launchers
+    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, selectedModules);
+    const agentCount = await agentGen.writeDashArtifacts(workflowsPath, agentArtifacts);
+    this._collectPromptEntries(writtenFiles, agentArtifacts, ['agent-launcher'], 'agent');
+
+    // Generate and write workflow commands
+    const workflowGen = new WorkflowCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(xiaomaDir);
+    const workflowCount = await workflowGen.writeDashArtifacts(workflowsPath, workflowArtifacts);
+    this._collectPromptEntries(writtenFiles, workflowArtifacts, ['workflow-command'], 'workflow');
+
+    // Generate and write task/tool commands
+    const taskToolGen = new TaskToolCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: taskToolArtifacts, counts: taskToolCounts } = await taskToolGen.collectTaskToolArtifacts(xiaomaDir);
+    await taskToolGen.writeDashArtifacts(workflowsPath, taskToolArtifacts);
+    const taskCount = taskToolCounts.tasks || 0;
+    const toolCount = taskToolCounts.tools || 0;
+    this._collectPromptEntries(writtenFiles, taskToolArtifacts, ['task', 'tool']);
+
+    // Generate prompts.yml manifest (only if we have entries to write)
+    if (writtenFiles.length > 0) {
+      await this.generatePromptsYml(projectDir, writtenFiles);
+    }
+
+    if (!options.silent) {
+      await prompts.log.success(
+        `${this.name} configured: ${agentCount} agents, ${workflowCount} workflows, ${taskCount} tasks, ${toolCount} tools`,
+      );
+    }
+
+    return {
+      success: true,
+      results: {
+        agents: agentCount,
+        workflows: workflowCount,
+        tasks: taskCount,
+        tools: toolCount,
+      },
+    };
+  }
+
+  /**
+   * Collect prompt entries from artifacts into writtenFiles array
+   * @param {Array} writtenFiles - Target array to push entries into
+   * @param {Array} artifacts - Artifacts from a generator's collect method
+   * @param {string[]} acceptedTypes - Artifact types to include (e.g., ['agent-launcher'])
+   * @param {string} [fallbackSuffix] - Suffix for fallback description; defaults to artifact.type
+   */
+  _collectPromptEntries(writtenFiles, artifacts, acceptedTypes, fallbackSuffix) {
+    for (const artifact of artifacts) {
+      if (!acceptedTypes.includes(artifact.type)) continue;
+      const flatName = toDashPath(artifact.relativePath);
+      writtenFiles.push({
+        name: path.basename(flatName, '.md'),
+        description: artifact.description || `${artifact.name} ${fallbackSuffix || artifact.type}`,
+        contentFile: `${this.workflowsDir}/${flatName}`,
+      });
+    }
+  }
+
+  /**
+   * Generate .rovodev/prompts.yml manifest
+   * Merges with existing user entries -- strips entries with names starting 'xiaoma-',
+   * appends new XIAOMA entries, and writes back.
+   *
+   * @param {string} projectDir - Project directory
+   * @param {Array<Object>} writtenFiles - Array of { name, description, contentFile }
+   */
+  async generatePromptsYml(projectDir, writtenFiles) {
+    const promptsPath = path.join(projectDir, this.rovoDir, this.promptsFile);
+    let existingPrompts = [];
+
+    // Read existing prompts.yml and preserve non-XIAOMA entries
+    if (await this.pathExists(promptsPath)) {
+      try {
+        const content = await this.readFile(promptsPath);
+        const parsed = yaml.parse(content);
+        if (parsed && Array.isArray(parsed.prompts)) {
+          // Keep only non-XIAOMA entries (entries whose name does NOT start with xiaoma-)
+          existingPrompts = parsed.prompts.filter((entry) => !entry.name || !entry.name.startsWith('xiaoma-'));
+        }
+      } catch {
+        // If parsing fails, start fresh but preserve file safety
+        existingPrompts = [];
+      }
+    }
+
+    // Build new XIAOMA entries (prefix description with name so /prompts list is scannable)
+    const xiaomaEntries = writtenFiles.map((file) => ({
+      name: file.name,
+      description: `${file.name} - ${file.description}`,
+      content_file: file.contentFile,
+    }));
+
+    // Merge: user entries first, then XIAOMA entries
+    const allPrompts = [...existingPrompts, ...xiaomaEntries];
+
+    const config = { prompts: allPrompts };
+    const yamlContent = yaml.stringify(config, { lineWidth: 0 });
+    await this.writeFile(promptsPath, yamlContent);
+  }
+
+  /**
+   * Cleanup Rovo Dev configuration
+   * Removes xiaoma-* files from .rovodev/workflows/ and strips XIAOMA entries from prompts.yml
+   * @param {string} projectDir - Project directory
+   * @param {Object} options - Cleanup options
+   */
+  async cleanup(projectDir, options = {}) {
+    const workflowsPath = path.join(projectDir, this.rovoDir, this.workflowsDir);
+
+    // Remove all xiaoma-* entries from workflows dir (aligned with detect() predicate)
+    if (await this.pathExists(workflowsPath)) {
+      const entries = await fs.readdir(workflowsPath);
+      for (const entry of entries) {
+        if (entry.startsWith('xiaoma-')) {
+          await fs.remove(path.join(workflowsPath, entry));
+        }
+      }
+    }
+
+    // Clean XIAOMA entries from prompts.yml (preserve user entries)
+    const promptsPath = path.join(projectDir, this.rovoDir, this.promptsFile);
+    if (await this.pathExists(promptsPath)) {
+      try {
+        const content = await this.readFile(promptsPath);
+        const parsed = yaml.parse(content) || {};
+
+        if (Array.isArray(parsed.prompts)) {
+          const originalCount = parsed.prompts.length;
+          parsed.prompts = parsed.prompts.filter((entry) => !entry.name || !entry.name.startsWith('xiaoma-'));
+          const removedCount = originalCount - parsed.prompts.length;
+
+          if (removedCount > 0) {
+            if (parsed.prompts.length === 0) {
+              // If no entries remain, remove the file entirely
+              await fs.remove(promptsPath);
+            } else {
+              await this.writeFile(promptsPath, yaml.stringify(parsed, { lineWidth: 0 }));
+            }
+            if (!options.silent) {
+              await prompts.log.message(`Removed ${removedCount} XIAOMA entries from ${this.promptsFile}`);
+            }
+          }
+        }
+      } catch {
+        // If parsing fails, leave file as-is
+        if (!options.silent) {
+          await prompts.log.warn(`Warning: Could not parse ${this.promptsFile} for cleanup`);
+        }
+      }
+    }
+
+    // Remove empty .rovodev directories
+    if (await this.pathExists(workflowsPath)) {
+      const remaining = await fs.readdir(workflowsPath);
+      if (remaining.length === 0) {
+        await fs.remove(workflowsPath);
+      }
+    }
+
+    const rovoDirPath = path.join(projectDir, this.rovoDir);
+    if (await this.pathExists(rovoDirPath)) {
+      const remaining = await fs.readdir(rovoDirPath);
+      if (remaining.length === 0) {
+        await fs.remove(rovoDirPath);
+      }
+    }
+  }
+
+  /**
+   * Detect whether Rovo Dev configuration exists in the project
+   * Checks for .rovodev/ dir with xiaoma files or xiaoma entries in prompts.yml
+   * @param {string} projectDir - Project directory
+   * @returns {boolean}
+   */
+  async detect(projectDir) {
+    const workflowsPath = path.join(projectDir, this.rovoDir, this.workflowsDir);
+
+    // Check for xiaoma files in workflows dir
+    if (await fs.pathExists(workflowsPath)) {
+      const entries = await fs.readdir(workflowsPath);
+      if (entries.some((entry) => entry.startsWith('xiaoma-'))) {
+        return true;
+      }
+    }
+
+    // Check for xiaoma entries in prompts.yml
+    const promptsPath = path.join(projectDir, this.rovoDir, this.promptsFile);
+    if (await fs.pathExists(promptsPath)) {
+      try {
+        const content = await fs.readFile(promptsPath, 'utf8');
+        const parsed = yaml.parse(content);
+        if (parsed && Array.isArray(parsed.prompts)) {
+          return parsed.prompts.some((entry) => entry.name && entry.name.startsWith('xiaoma-'));
+        }
+      } catch {
+        // If parsing fails, check raw content
+        return false;
+      }
+    }
+
+    return false;
+  }
+}
+
+module.exports = { RovoDevSetup };

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 { toColonPath, toDashPath, customAgentColonName, customAgentDashName, XiaoMa_FOLDER_NAME } = require('./path-utils');
+
+/**
+ * Generates launcher command files for each agent
+ * Similar to WorkflowCommandGenerator but for agents
+ */
+class AgentCommandGenerator {
+  constructor(xiaomaFolderName = XiaoMa_FOLDER_NAME) {
+    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 { getAgentsFromXiaoMa } = require('./xiaoma-artifacts');
+
+    // Get agents from INSTALLED xiaoma/ directory
+    const agents = await getAgentsFromXiaoMa(xiaomaDir, 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., xmc/agents/pm.md)
+      let agentRelPath = agent.path || '';
+      // Normalize path separators for cross-platform compatibility
+      agentRelPath = agentRelPath.replaceAll('\\', '/');
+      // Remove _xiaoma/ prefix if present to get relative path from project root
+      // Handle both absolute paths (/path/to/_xiaoma/...) and relative paths (_xiaoma/...)
+      if (agentRelPath.includes('_xiaoma/')) {
+        const parts = agentRelPath.split(/_xiaoma\//);
+        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,
+        canonicalId: agent.canonicalId || '',
+        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('_xiaoma', this.xiaomaFolderName)
+      .replaceAll('_xiaoma', '_xiaoma');
+  }
+
+  /**
+   * 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: xiaoma_xmc_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: xmc/agents/pm.md → xiaoma_xmc_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: xiaoma-agent-xmc-pm.md
+   *
+   * The xiaoma-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: xmc/agents/pm.md → xiaoma-agent-xmc-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/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,
+};