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

package/tools/cli/installers/lib/core/detector.js

@@ -0,0 +1,329 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { Manifest } = require('./manifest');
+
+class Detector {
+  /**
+   * Detect existing XIAOMA installation
+   * @param {string} xiaomaDir - Path to xiaoma directory
+   * @returns {Object} Installation status and details
+   */
+  async detect(xiaomaDir) {
+    const result = {
+      installed: false,
+      path: xiaomaDir,
+      version: null,
+      hasCore: false,
+      modules: [],
+      ides: [],
+      manifest: null,
+    };
+
+    // Check if xiaoma directory exists
+    if (!(await fs.pathExists(xiaomaDir))) {
+      return result;
+    }
+
+    // Check for manifest using the Manifest class
+    const manifest = new Manifest();
+    const manifestData = await manifest.read(xiaomaDir);
+    if (manifestData) {
+      result.manifest = manifestData;
+      result.version = manifestData.version;
+      result.installed = true;
+    }
+
+    // Check for core
+    const corePath = path.join(xiaomaDir, 'core');
+    if (await fs.pathExists(corePath)) {
+      result.hasCore = true;
+
+      // Try to get core version from config
+      const coreConfigPath = path.join(corePath, 'config.yaml');
+      if (await fs.pathExists(coreConfigPath)) {
+        try {
+          const configContent = await fs.readFile(coreConfigPath, 'utf8');
+          const config = yaml.load(configContent);
+          if (!result.version && config.version) {
+            result.version = config.version;
+          }
+        } catch {
+          // Ignore config read errors
+        }
+      }
+    }
+
+    // Check for modules
+    // If manifest exists, use it as the source of truth for installed modules
+    // Otherwise fall back to directory scanning (legacy installations)
+    if (manifestData && manifestData.modules && manifestData.modules.length > 0) {
+      // Use manifest module list - these are officially installed modules
+      for (const moduleId of manifestData.modules) {
+        const modulePath = path.join(xiaomaDir, moduleId);
+        const moduleConfigPath = path.join(modulePath, 'config.yaml');
+
+        const moduleInfo = {
+          id: moduleId,
+          path: modulePath,
+          version: 'unknown',
+        };
+
+        if (await fs.pathExists(moduleConfigPath)) {
+          try {
+            const configContent = await fs.readFile(moduleConfigPath, 'utf8');
+            const config = yaml.load(configContent);
+            moduleInfo.version = config.version || 'unknown';
+            moduleInfo.name = config.name || moduleId;
+            moduleInfo.description = config.description;
+          } catch {
+            // Ignore config read errors
+          }
+        }
+
+        result.modules.push(moduleInfo);
+      }
+    } else {
+      // Fallback: scan directory for modules (legacy installations without manifest)
+      const entries = await fs.readdir(xiaomaDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
+          const modulePath = path.join(xiaomaDir, entry.name);
+          const moduleConfigPath = path.join(modulePath, 'config.yaml');
+
+          // Only treat it as a module if it has a config.yaml
+          if (await fs.pathExists(moduleConfigPath)) {
+            const moduleInfo = {
+              id: entry.name,
+              path: modulePath,
+              version: 'unknown',
+            };
+
+            try {
+              const configContent = await fs.readFile(moduleConfigPath, 'utf8');
+              const config = yaml.load(configContent);
+              moduleInfo.version = config.version || 'unknown';
+              moduleInfo.name = config.name || entry.name;
+              moduleInfo.description = config.description;
+            } catch {
+              // Ignore config read errors
+            }
+
+            result.modules.push(moduleInfo);
+          }
+        }
+      }
+    }
+
+    // Check for IDE configurations from manifest
+    if (result.manifest && result.manifest.ides) {
+      // Filter out any undefined/null values
+      result.ides = result.manifest.ides.filter((ide) => ide && typeof ide === 'string');
+    }
+
+    // Mark as installed if we found core or modules
+    if (result.hasCore || result.modules.length > 0) {
+      result.installed = true;
+    }
+
+    return result;
+  }
+
+  /**
+   * Detect legacy installation (.xiaoma-cli, .xmc, .cis)
+   * @param {string} projectDir - Project directory to check
+   * @returns {Object} Legacy installation details
+   */
+  async detectLegacy(projectDir) {
+    const result = {
+      hasLegacy: false,
+      legacyCore: false,
+      legacyModules: [],
+      paths: [],
+    };
+
+    // Check for legacy core (.xiaoma-cli)
+    const legacyCorePath = path.join(projectDir, '.xiaoma-cli');
+    if (await fs.pathExists(legacyCorePath)) {
+      result.hasLegacy = true;
+      result.legacyCore = true;
+      result.paths.push(legacyCorePath);
+    }
+
+    // Check for legacy modules (directories starting with .)
+    const entries = await fs.readdir(projectDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (
+        entry.isDirectory() &&
+        entry.name.startsWith('.') &&
+        entry.name !== '.xiaoma-cli' &&
+        !entry.name.startsWith('.git') &&
+        !entry.name.startsWith('.vscode') &&
+        !entry.name.startsWith('.idea')
+      ) {
+        const modulePath = path.join(projectDir, entry.name);
+        const moduleManifestPath = path.join(modulePath, 'install-manifest.yaml');
+
+        // Check if it's likely a XIAOMA module
+        if ((await fs.pathExists(moduleManifestPath)) || (await fs.pathExists(path.join(modulePath, 'config.yaml')))) {
+          result.hasLegacy = true;
+          result.legacyModules.push({
+            name: entry.name.slice(1), // Remove leading dot
+            path: modulePath,
+          });
+          result.paths.push(modulePath);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if migration from legacy is needed
+   * @param {string} projectDir - Project directory
+   * @returns {Object} Migration requirements
+   */
+  async checkMigrationNeeded(projectDir) {
+    const xiaomaDir = path.join(projectDir, 'xiaoma');
+    const current = await this.detect(xiaomaDir);
+    const legacy = await this.detectLegacy(projectDir);
+
+    return {
+      needed: legacy.hasLegacy && !current.installed,
+      canMigrate: legacy.hasLegacy,
+      legacy: legacy,
+      current: current,
+    };
+  }
+
+  /**
+   * Detect legacy XIAOMA v4 footprints (case-sensitive path checks)
+   * V4 used .xiaoma-cli as default folder name
+   * V6+ uses configurable folder names and ALWAYS has _cfg/manifest.yaml with installation.version
+   * @param {string} projectDir - Project directory to check
+   * @returns {{ hasLegacyV4: boolean, offenders: string[] }}
+   */
+  async detectLegacyV4(projectDir) {
+    // Helper: check existence of a nested path with case-sensitive segment matching
+    const existsCaseSensitive = async (baseDir, segments) => {
+      let dir = baseDir;
+      for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+          return false;
+        }
+        const hit = entries.find((e) => e.name === seg);
+        if (!hit) return false;
+        // Parents must be directories; the last segment may be a file or directory
+        if (i < segments.length - 1 && !hit.isDirectory()) return false;
+        dir = path.join(dir, hit.name);
+      }
+      return true;
+    };
+
+    // Helper: check if a directory is a V6+ installation
+    const isV6Installation = async (dirPath) => {
+      const manifestPath = path.join(dirPath, '_cfg', 'manifest.yaml');
+      if (!(await fs.pathExists(manifestPath))) {
+        return false;
+      }
+      try {
+        const yaml = require('js-yaml');
+        const manifestContent = await fs.readFile(manifestPath, 'utf8');
+        const manifest = yaml.load(manifestContent);
+        // V6+ manifest has installation.version
+        return manifest && manifest.installation && manifest.installation.version;
+      } catch {
+        return false;
+      }
+    };
+
+    const offenders = [];
+
+    // Strategy:
+    // 1. First scan for ANY V6+ installation (_cfg/manifest.yaml)
+    // 2. If V6+ found → don't flag anything (user is already on V6+)
+    // 3. If NO V6+ found → flag folders with "xiaoma" in name as potential V4 legacy
+
+    let hasV6Installation = false;
+    const potentialV4Folders = [];
+
+    try {
+      const entries = await fs.readdir(projectDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const name = entry.name;
+          const fullPath = path.join(projectDir, entry.name);
+
+          // Check if directory is empty (skip empty leftover folders)
+          const dirContents = await fs.readdir(fullPath);
+          if (dirContents.length === 0) {
+            continue; // Skip empty folders
+          }
+
+          // Check if it's a V6+ installation by looking for _cfg/manifest.yaml
+          // This works for ANY folder name (not just xiaoma-prefixed)
+          const isV6 = await isV6Installation(fullPath);
+
+          if (isV6) {
+            // Found a V6+ installation - user is already on V6+
+            hasV6Installation = true;
+            // Don't break - continue scanning to be thorough
+          } else {
+            // Not V6+, check if folder name contains "xiaoma" (case insensitive)
+            const nameLower = name.toLowerCase();
+            if (nameLower.includes('xiaoma')) {
+              // Potential V4 legacy folder
+              potentialV4Folders.push(fullPath);
+            }
+          }
+        }
+      }
+    } catch {
+      // Ignore errors reading directory
+    }
+
+    // Only flag V4 folders if NO V6+ installation was found
+    if (!hasV6Installation && potentialV4Folders.length > 0) {
+      offenders.push(...potentialV4Folders);
+    }
+
+    // Check inside various IDE command folders for legacy xiaoma folders
+    // V4 used folders like 'xiaoma-cli' or custom names in IDE commands
+    // V6+ uses 'xiaoma' in IDE commands (hardcoded in IDE handlers)
+    // Legacy V4 IDE command folders won't have a corresponding V6+ installation
+    const ideConfigFolders = ['.opencode', '.claude', '.crush', '.continue', '.cursor', '.windsurf', '.cline', '.roo-cline'];
+
+    for (const ideFolder of ideConfigFolders) {
+      const commandsDirName = ideFolder === '.opencode' ? 'command' : 'commands';
+      const commandsPath = path.join(projectDir, ideFolder, commandsDirName);
+      if (await fs.pathExists(commandsPath)) {
+        try {
+          const commandEntries = await fs.readdir(commandsPath, { withFileTypes: true });
+          for (const entry of commandEntries) {
+            if (entry.isDirectory()) {
+              const name = entry.name;
+              // V4 used 'xiaoma-cli' or similar in IDE commands folders
+              // V6+ uses 'xiaoma' (hardcoded)
+              // So anything that's NOT 'xiaoma' but starts with xiaoma/Bmad is likely V4
+              if ((name.startsWith('xiaoma') || name.startsWith('Bmad') || name === 'XiaoMa') && name !== 'xiaoma') {
+                offenders.push(path.join(commandsPath, entry.name));
+              }
+            }
+          }
+        } catch {
+          // Ignore errors reading commands directory
+        }
+      }
+    }
+
+    return { hasLegacyV4: offenders.length > 0, offenders };
+  }
+}
+
+module.exports = { Detector };

package/tools/cli/installers/lib/core/ide-config-manager.js

@@ -0,0 +1,154 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+
+/**
+ * Manages IDE configuration persistence
+ * Saves and loads IDE-specific configurations to/from xiaoma/_cfg/ides/
+ */
+class IdeConfigManager {
+  constructor() {}
+
+  /**
+   * Get path to IDE config directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @returns {string} Path to IDE config directory
+   */
+  getIdeConfigDir(xiaomaDir) {
+    return path.join(xiaomaDir, '_cfg', 'ides');
+  }
+
+  /**
+   * Get path to specific IDE config file
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {string} ideName - IDE name (e.g., 'claude-code')
+   * @returns {string} Path to IDE config file
+   */
+  getIdeConfigPath(xiaomaDir, ideName) {
+    return path.join(this.getIdeConfigDir(xiaomaDir), `${ideName}.yaml`);
+  }
+
+  /**
+   * Save IDE configuration
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {string} ideName - IDE name
+   * @param {Object} configuration - IDE-specific configuration object
+   */
+  async saveIdeConfig(xiaomaDir, ideName, configuration) {
+    const configDir = this.getIdeConfigDir(xiaomaDir);
+    await fs.ensureDir(configDir);
+
+    const configPath = this.getIdeConfigPath(xiaomaDir, ideName);
+    const now = new Date().toISOString();
+
+    // Check if config already exists to preserve configured_date
+    let configuredDate = now;
+    if (await fs.pathExists(configPath)) {
+      try {
+        const existing = await this.loadIdeConfig(xiaomaDir, ideName);
+        if (existing && existing.configured_date) {
+          configuredDate = existing.configured_date;
+        }
+      } catch {
+        // Ignore errors reading existing config
+      }
+    }
+
+    const configData = {
+      ide: ideName,
+      configured_date: configuredDate,
+      last_updated: now,
+      configuration: configuration || {},
+    };
+
+    const yamlContent = yaml.dump(configData, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true,
+      sortKeys: false,
+    });
+
+    // Ensure POSIX-compliant final newline
+    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
+    await fs.writeFile(configPath, content, 'utf8');
+  }
+
+  /**
+   * Load IDE configuration
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {string} ideName - IDE name
+   * @returns {Object|null} IDE configuration or null if not found
+   */
+  async loadIdeConfig(xiaomaDir, ideName) {
+    const configPath = this.getIdeConfigPath(xiaomaDir, ideName);
+
+    if (!(await fs.pathExists(configPath))) {
+      return null;
+    }
+
+    try {
+      const content = await fs.readFile(configPath, 'utf8');
+      const config = yaml.load(content);
+      return config;
+    } catch (error) {
+      console.warn(`Warning: Failed to load IDE config for ${ideName}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Load all IDE configurations
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @returns {Object} Map of IDE name to configuration
+   */
+  async loadAllIdeConfigs(xiaomaDir) {
+    const configDir = this.getIdeConfigDir(xiaomaDir);
+    const configs = {};
+
+    if (!(await fs.pathExists(configDir))) {
+      return configs;
+    }
+
+    try {
+      const files = await fs.readdir(configDir);
+      for (const file of files) {
+        if (file.endsWith('.yaml')) {
+          const ideName = file.replace('.yaml', '');
+          const config = await this.loadIdeConfig(xiaomaDir, ideName);
+          if (config) {
+            configs[ideName] = config.configuration;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('Warning: Failed to load IDE configs:', error.message);
+    }
+
+    return configs;
+  }
+
+  /**
+   * Check if IDE has saved configuration
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {string} ideName - IDE name
+   * @returns {boolean} True if configuration exists
+   */
+  async hasIdeConfig(xiaomaDir, ideName) {
+    const configPath = this.getIdeConfigPath(xiaomaDir, ideName);
+    return await fs.pathExists(configPath);
+  }
+
+  /**
+   * Delete IDE configuration
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {string} ideName - IDE name
+   */
+  async deleteIdeConfig(xiaomaDir, ideName) {
+    const configPath = this.getIdeConfigPath(xiaomaDir, ideName);
+    if (await fs.pathExists(configPath)) {
+      await fs.remove(configPath);
+    }
+  }
+}
+
+module.exports = { IdeConfigManager };