@zeyue0329/xiaoma-cli 1.0.49 → 1.6.4

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

@@ -0,0 +1,304 @@
+const { XiaoMa_FOLDER_NAME } = require('./shared/path-utils');
+const prompts = require('../../../lib/prompts');
+
+/**
+ * IDE Manager - handles IDE-specific setup
+ * Dynamically discovers and loads IDE handlers
+ *
+ * Loading strategy:
+ * All platforms are config-driven from platform-codes.yaml.
+ */
+class IdeManager {
+  constructor() {
+    this.handlers = new Map();
+    this._initialized = false;
+    this.xiaomaFolderName = XiaoMa_FOLDER_NAME; // Default, can be overridden
+  }
+
+  /**
+   * Set the xiaoma folder name for all IDE handlers
+   * @param {string} xiaomaFolderName - The xiaoma folder name
+   */
+  setXiaoMaFolderName(xiaomaFolderName) {
+    this.xiaomaFolderName = xiaomaFolderName;
+    // Update all loaded handlers
+    for (const handler of this.handlers.values()) {
+      if (typeof handler.setXiaoMaFolderName === 'function') {
+        handler.setXiaoMaFolderName(xiaomaFolderName);
+      }
+    }
+  }
+
+  /**
+   * Ensure handlers are loaded (lazy loading)
+   */
+  async ensureInitialized() {
+    if (!this._initialized) {
+      await this.loadHandlers();
+      this._initialized = true;
+    }
+  }
+
+  /**
+   * Dynamically load all IDE handlers from platform-codes.yaml
+   */
+  async loadHandlers() {
+    await this.loadConfigDrivenHandlers();
+  }
+
+  /**
+   * Load config-driven handlers from platform-codes.yaml
+   * This creates ConfigDrivenIdeSetup instances for platforms with installer config
+   */
+  async loadConfigDrivenHandlers() {
+    const { loadPlatformCodes } = require('./platform-codes');
+    const platformConfig = await loadPlatformCodes();
+
+    const { ConfigDrivenIdeSetup } = require('./_config-driven');
+
+    for (const [platformCode, platformInfo] of Object.entries(platformConfig.platforms)) {
+      // Skip if no installer config (platform may not need installation)
+      if (!platformInfo.installer) continue;
+
+      const handler = new ConfigDrivenIdeSetup(platformCode, platformInfo);
+      if (typeof handler.setXiaoMaFolderName === 'function') {
+        handler.setXiaoMaFolderName(this.xiaomaFolderName);
+      }
+      this.handlers.set(platformCode, handler);
+    }
+  }
+
+  /**
+   * Get all available IDEs with their metadata
+   * @returns {Array} Array of IDE information objects
+   */
+  getAvailableIdes() {
+    const ides = [];
+
+    for (const [key, handler] of this.handlers) {
+      // Skip handlers without valid names
+      const name = handler.displayName || handler.name || key;
+
+      // Filter out invalid entries (undefined name, empty key, etc.)
+      if (!key || !name || typeof key !== 'string' || typeof name !== 'string') {
+        continue;
+      }
+
+      // Skip suspended platforms (e.g., IDE doesn't support skills yet)
+      if (handler.platformConfig?.suspended) {
+        continue;
+      }
+
+      ides.push({
+        value: key,
+        name: name,
+        preferred: handler.preferred || false,
+      });
+    }
+
+    // Sort: preferred first, then alphabetical
+    ides.sort((a, b) => {
+      if (a.preferred && !b.preferred) return -1;
+      if (!a.preferred && b.preferred) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return ides;
+  }
+
+  /**
+   * Get preferred IDEs
+   * @returns {Array} Array of preferred IDE information
+   */
+  getPreferredIdes() {
+    return this.getAvailableIdes().filter((ide) => ide.preferred);
+  }
+
+  /**
+   * Get non-preferred IDEs
+   * @returns {Array} Array of non-preferred IDE information
+   */
+  getOtherIdes() {
+    return this.getAvailableIdes().filter((ide) => !ide.preferred);
+  }
+
+  /**
+   * Setup IDE configuration
+   * @param {string} ideName - Name of the IDE
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XiaoMa installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(ideName, projectDir, xiaomaDir, options = {}) {
+    const handler = this.handlers.get(ideName.toLowerCase());
+
+    if (!handler) {
+      await prompts.log.warn(`IDE '${ideName}' is not yet supported`);
+      await prompts.log.message(`Supported IDEs: ${[...this.handlers.keys()].join(', ')}`);
+      return { success: false, ide: ideName, error: 'unsupported IDE' };
+    }
+
+    // Block suspended platforms — clean up legacy files but don't install
+    if (handler.platformConfig?.suspended) {
+      if (!options.silent) {
+        await prompts.log.warn(`${handler.displayName || ideName}: ${handler.platformConfig.suspended}`);
+      }
+      // Still clean up legacy artifacts so old broken configs don't linger
+      if (typeof handler.cleanup === 'function') {
+        try {
+          await handler.cleanup(projectDir, { silent: true });
+        } catch {
+          // Best-effort cleanup — don't let stale files block the suspended result
+        }
+      }
+      return { success: false, ide: ideName, error: 'suspended' };
+    }
+
+    try {
+      const handlerResult = await handler.setup(projectDir, xiaomaDir, options);
+      // Build detail string from handler-returned data
+      let detail = '';
+      if (handlerResult && handlerResult.results) {
+        // Config-driven handlers return { success, results: { agents, workflows, tasks, tools } }
+        const r = handlerResult.results;
+        const parts = [];
+        if (r.agents > 0) parts.push(`${r.agents} agents`);
+        if (r.workflows > 0) parts.push(`${r.workflows} workflows`);
+        if (r.tasks > 0) parts.push(`${r.tasks} tasks`);
+        if (r.tools > 0) parts.push(`${r.tools} tools`);
+        detail = parts.join(', ');
+      }
+      // Propagate handler's success status (default true for backward compat)
+      const success = handlerResult?.success !== false;
+      return { success, ide: ideName, detail, error: handlerResult?.error, handlerResult };
+    } catch (error) {
+      await prompts.log.error(`Failed to setup ${ideName}: ${error.message}`);
+      return { success: false, ide: ideName, error: error.message };
+    }
+  }
+
+  /**
+   * Cleanup IDE configurations
+   * @param {string} projectDir - Project directory
+   * @param {Object} [options] - Cleanup options passed through to handlers
+   */
+  async cleanup(projectDir, options = {}) {
+    const results = [];
+
+    for (const [name, handler] of this.handlers) {
+      try {
+        await handler.cleanup(projectDir, options);
+        results.push({ ide: name, success: true });
+      } catch (error) {
+        results.push({ ide: name, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Cleanup only the IDEs in the provided list
+   * Falls back to cleanup() (all handlers) if ideList is empty or undefined
+   * @param {string} projectDir - Project directory
+   * @param {Array<string>} ideList - List of IDE names to clean up
+   * @param {Object} [options] - Cleanup options passed through to handlers
+   * @returns {Array} Results array
+   */
+  async cleanupByList(projectDir, ideList, options = {}) {
+    if (!ideList || ideList.length === 0) {
+      return this.cleanup(projectDir, options);
+    }
+
+    await this.ensureInitialized();
+    const results = [];
+
+    // Build lowercase lookup for case-insensitive matching
+    const lowercaseHandlers = new Map([...this.handlers.entries()].map(([k, v]) => [k.toLowerCase(), v]));
+
+    for (const ideName of ideList) {
+      const handler = lowercaseHandlers.get(ideName.toLowerCase());
+      if (!handler) continue;
+
+      try {
+        await handler.cleanup(projectDir, options);
+        results.push({ ide: ideName, success: true });
+      } catch (error) {
+        results.push({ ide: ideName, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get list of supported IDEs
+   * @returns {Array} List of supported IDE names
+   */
+  getSupportedIdes() {
+    return [...this.handlers.keys()];
+  }
+
+  /**
+   * Check if an IDE is supported
+   * @param {string} ideName - Name of the IDE
+   * @returns {boolean} True if IDE is supported
+   */
+  isSupported(ideName) {
+    return this.handlers.has(ideName.toLowerCase());
+  }
+
+  /**
+   * Detect installed IDEs
+   * @param {string} projectDir - Project directory
+   * @returns {Array} List of detected IDEs
+   */
+  async detectInstalledIdes(projectDir) {
+    const detected = [];
+
+    for (const [name, handler] of this.handlers) {
+      if (typeof handler.detect === 'function' && (await handler.detect(projectDir))) {
+        detected.push(name);
+      }
+    }
+
+    return detected;
+  }
+
+  /**
+   * Install custom agent launchers for specified IDEs
+   * @param {Array} ides - List of IDE names to install for
+   * @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} Results for each IDE
+   */
+  async installCustomAgentLaunchers(ides, projectDir, agentName, agentPath, metadata) {
+    const results = {};
+
+    for (const ideName of ides) {
+      const handler = this.handlers.get(ideName.toLowerCase());
+
+      if (!handler) {
+        await prompts.log.warn(`IDE '${ideName}' is not yet supported for custom agent installation`);
+        continue;
+      }
+
+      try {
+        if (typeof handler.installCustomAgentLauncher === 'function') {
+          const result = await handler.installCustomAgentLauncher(projectDir, agentName, agentPath, metadata);
+          if (result) {
+            results[ideName] = result;
+          }
+        }
+      } catch (error) {
+        await prompts.log.warn(`Failed to install ${ideName} launcher: ${error.message}`);
+      }
+    }
+
+    return results;
+  }
+}
+
+module.exports = { IdeManager };

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

@@ -0,0 +1,257 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const os = require('node:os');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const { BaseIdeSetup } = require('./_base-ide');
+const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * OpenCode IDE setup handler
+ */
+class OpenCodeSetup extends BaseIdeSetup {
+  constructor() {
+    super('opencode', 'OpenCode', true); // Mark as preferred/recommended
+    this.configDir = '.opencode';
+    this.commandsDir = 'command';
+    this.agentsDir = 'agent';
+  }
+
+  async setup(projectDir, xiaomaDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    const baseDir = path.join(projectDir, this.configDir);
+    const commandsBaseDir = path.join(baseDir, this.commandsDir);
+    const agentsBaseDir = path.join(baseDir, this.agentsDir);
+
+    await this.ensureDir(commandsBaseDir);
+    await this.ensureDir(agentsBaseDir);
+
+    // Clean up any existing XIAOMA files before reinstalling
+    await this.cleanup(projectDir);
+
+    // Generate agent launchers
+    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, options.selectedModules || []);
+
+    // Install primary agents with flat naming: xiaoma-agent-{module}-{name}.md
+    // OpenCode agents go in the agent folder (not command folder)
+    let agentCount = 0;
+    for (const artifact of agentArtifacts) {
+      const agentContent = artifact.content;
+      // Flat structure in agent folder: xiaoma-agent-{module}-{name}.md
+      const targetPath = path.join(agentsBaseDir, `xiaoma-agent-${artifact.module}-${artifact.name}.md`);
+      await this.writeFile(targetPath, agentContent);
+      agentCount++;
+    }
+
+    // Install workflow commands with flat naming: xiaoma-workflow-{module}-{name}.md
+    const workflowGenerator = new WorkflowCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(xiaomaDir);
+
+    let workflowCommandCount = 0;
+    for (const artifact of workflowArtifacts) {
+      if (artifact.type === 'workflow-command') {
+        const commandContent = artifact.content;
+        // Flat structure: xiaoma-workflow-{module}-{name}.md
+        // artifact.relativePath is like: xmc/workflows/plan-project.md
+        const workflowName = path.basename(artifact.relativePath, '.md');
+        const targetPath = path.join(commandsBaseDir, `xiaoma-workflow-${artifact.module}-${workflowName}.md`);
+        await this.writeFile(targetPath, commandContent);
+        workflowCommandCount++;
+      }
+      // Skip workflow launcher READMEs as they're not needed in flat structure
+    }
+
+    // Install task and tool commands with flat naming
+    const { tasks, tools } = await this.generateFlatTaskToolCommands(xiaomaDir, commandsBaseDir);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents installed to .opencode/agent/`));
+    if (workflowCommandCount > 0) {
+      console.log(chalk.dim(`  - ${workflowCommandCount} workflows installed to .opencode/command/`));
+    }
+    if (tasks + tools > 0) {
+      console.log(chalk.dim(`  - ${tasks + tools} tasks/tools installed to .opencode/command/ (${tasks} tasks, ${tools} tools)`));
+    }
+
+    return {
+      success: true,
+      agents: agentCount,
+      workflows: workflowCommandCount,
+      workflowCounts,
+    };
+  }
+
+  /**
+   * Generate flat task and tool commands for OpenCode
+   * OpenCode doesn't support nested command directories
+   */
+  async generateFlatTaskToolCommands(xiaomaDir, commandsBaseDir) {
+    const taskToolGen = new TaskToolCommandGenerator();
+    const tasks = await taskToolGen.loadTaskManifest(xiaomaDir);
+    const tools = await taskToolGen.loadToolManifest(xiaomaDir);
+
+    // 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) : [];
+
+    // Generate command files for tasks with flat naming: xiaoma-task-{module}-{name}.md
+    for (const task of standaloneTasks) {
+      const commandContent = taskToolGen.generateCommandContent(task, 'task');
+      const targetPath = path.join(commandsBaseDir, `xiaoma-task-${task.module}-${task.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+    }
+
+    // Generate command files for tools with flat naming: xiaoma-tool-{module}-{name}.md
+    for (const tool of standaloneTools) {
+      const commandContent = taskToolGen.generateCommandContent(tool, 'tool');
+      const targetPath = path.join(commandsBaseDir, `xiaoma-tool-${tool.module}-${tool.name}.md`);
+      await this.writeFile(targetPath, commandContent);
+    }
+
+    return {
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  async readAndProcess(filePath, metadata) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return this.processContent(content, metadata);
+  }
+
+  async createAgentContent(content, metadata) {
+    const { frontmatter = {}, body } = this.parseFrontmatter(content);
+
+    frontmatter.description =
+      frontmatter.description && String(frontmatter.description).trim().length > 0
+        ? frontmatter.description
+        : `XIAOMA ${metadata.module} agent: ${metadata.name}`;
+
+    // OpenCode agents use: 'primary' mode for main agents
+    frontmatter.mode = 'primary';
+
+    const frontmatterString = this.stringifyFrontmatter(frontmatter);
+
+    // Get the activation header from central template
+    const activationHeader = await this.getAgentCommandHeader();
+
+    return `${frontmatterString}\n\n${activationHeader}\n\n${body}`;
+  }
+
+  parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+    if (!match) {
+      return { data: {}, body: content };
+    }
+
+    const body = content.slice(match[0].length);
+
+    let frontmatter = {};
+    try {
+      frontmatter = yaml.load(match[1]) || {};
+    } catch {
+      frontmatter = {};
+    }
+
+    return { frontmatter, body };
+  }
+
+  stringifyFrontmatter(frontmatter) {
+    const yamlText = yaml
+      .dump(frontmatter, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false,
+      })
+      .trimEnd();
+
+    return `---\n${yamlText}\n---`;
+  }
+
+  /**
+   * Cleanup OpenCode configuration - surgically remove only XIAOMA files
+   */
+  async cleanup(projectDir) {
+    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
+    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
+    let removed = 0;
+
+    // Clean up agent folder
+    if (await fs.pathExists(agentsDir)) {
+      const files = await fs.readdir(agentsDir);
+      for (const file of files) {
+        if (file.startsWith('xiaoma-') && file.endsWith('.md')) {
+          await fs.remove(path.join(agentsDir, file));
+          removed++;
+        }
+      }
+    }
+
+    // Clean up command folder
+    if (await fs.pathExists(commandsDir)) {
+      const files = await fs.readdir(commandsDir);
+      for (const file of files) {
+        if (file.startsWith('xiaoma-') && file.endsWith('.md')) {
+          await fs.remove(path.join(commandsDir, file));
+          removed++;
+        }
+      }
+    }
+
+    if (removed > 0) {
+      console.log(chalk.dim(`  Cleaned up ${removed} existing XIAOMA files`));
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for OpenCode
+   * @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|null} Info about created command
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
+
+    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
+      return null; // IDE not configured for this project
+    }
+
+    await this.ensureDir(agentsDir);
+
+    const launcherContent = `---
+name: '${agentName}'
+description: '${metadata.title || agentName} agent'
+mode: 'primary'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @${agentPath}
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. FOLLOW every step in the <activation> section precisely
+4. DISPLAY the welcome/greeting as instructed
+5. PRESENT the numbered menu
+6. WAIT for user input before proceeding
+</agent-activation>
+`;
+
+    // OpenCode uses flat naming: xiaoma-agent-custom-{name}.md
+    const launcherPath = path.join(agentsDir, `xiaoma-agent-custom-${agentName}.md`);
+    await this.writeFile(launcherPath, launcherContent);
+
+    return {
+      path: launcherPath,
+      command: `xiaoma-agent-custom-${agentName}`,
+    };
+  }
+}
+
+module.exports = { OpenCodeSetup };

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

@@ -0,0 +1,100 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('yaml');
+
+const PLATFORM_CODES_PATH = path.join(__dirname, 'platform-codes.yaml');
+
+let _cachedPlatformCodes = null;
+
+/**
+ * Load the platform codes configuration from YAML
+ * @returns {Object} Platform codes configuration
+ */
+async function loadPlatformCodes() {
+  if (_cachedPlatformCodes) {
+    return _cachedPlatformCodes;
+  }
+
+  if (!(await fs.pathExists(PLATFORM_CODES_PATH))) {
+    throw new Error(`Platform codes configuration not found at: ${PLATFORM_CODES_PATH}`);
+  }
+
+  const content = await fs.readFile(PLATFORM_CODES_PATH, 'utf8');
+  _cachedPlatformCodes = yaml.parse(content);
+  return _cachedPlatformCodes;
+}
+
+/**
+ * Get platform information by code
+ * @param {string} platformCode - Platform code (e.g., 'claude-code', 'cursor')
+ * @returns {Object|null} Platform info or null if not found
+ */
+function getPlatformInfo(platformCode) {
+  if (!_cachedPlatformCodes) {
+    throw new Error('Platform codes not loaded. Call loadPlatformCodes() first.');
+  }
+
+  return _cachedPlatformCodes.platforms[platformCode] || null;
+}
+
+/**
+ * Get all preferred platforms
+ * @returns {Promise<Array>} Array of preferred platform codes
+ */
+async function getPreferredPlatforms() {
+  const config = await loadPlatformCodes();
+  return Object.entries(config.platforms)
+    .filter(([_, info]) => info.preferred)
+    .map(([code, _]) => code);
+}
+
+/**
+ * Get all platform codes by category
+ * @param {string} category - Category to filter by (ide, cli, tool, etc.)
+ * @returns {Promise<Array>} Array of platform codes in the category
+ */
+async function getPlatformsByCategory(category) {
+  const config = await loadPlatformCodes();
+  return Object.entries(config.platforms)
+    .filter(([_, info]) => info.category === category)
+    .map(([code, _]) => code);
+}
+
+/**
+ * Get all platforms with installer config
+ * @returns {Promise<Array>} Array of platform codes that have installer config
+ */
+async function getConfigDrivenPlatforms() {
+  const config = await loadPlatformCodes();
+  return Object.entries(config.platforms)
+    .filter(([_, info]) => info.installer)
+    .map(([code, _]) => code);
+}
+
+/**
+ * Get platforms that use custom installers (no installer config)
+ * @returns {Promise<Array>} Array of platform codes with custom installers
+ */
+async function getCustomInstallerPlatforms() {
+  const config = await loadPlatformCodes();
+  return Object.entries(config.platforms)
+    .filter(([_, info]) => !info.installer)
+    .map(([code, _]) => code);
+}
+
+/**
+ * Clear the cached platform codes (useful for testing)
+ */
+function clearCache() {
+  _cachedPlatformCodes = null;
+}
+
+module.exports = {
+  loadPlatformCodes,
+  getPlatformInfo,
+  getPreferredPlatforms,
+  getPlatformsByCategory,
+  getConfigDrivenPlatforms,
+  getCustomInstallerPlatforms,
+  clearCache,
+};