@zeyue0329/xiaoma-cli 1.12.0 → 1.15.0

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

@@ -1,223 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const yaml = require('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: [],
-      customModules: [],
-      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;
-      // Copy custom modules if they exist
-      if (manifestData.customModules) {
-        result.customModules = manifestData.customModules;
-      }
-    }
-
-    // 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.parse(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.parse(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 !== '_config') {
-          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.parse(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 .xiaoma-cli folder
-   * @param {string} projectDir - Project directory to check
-   * @returns {{ hasLegacyV4: boolean, offenders: string[] }}
-   */
-  async detectLegacyV4(projectDir) {
-    const offenders = [];
-
-    // Check for .xiaoma-cli folder
-    const xiaomaMethodPath = path.join(projectDir, '.xiaoma-cli');
-    if (await fs.pathExists(xiaomaMethodPath)) {
-      offenders.push(xiaomaMethodPath);
-    }
-
-    return { hasLegacyV4: offenders.length > 0, offenders };
-  }
-}
-
-module.exports = { Detector };

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

@@ -1,157 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const yaml = require('yaml');
-const prompts = require('../../../lib/prompts');
-
-/**
- * Manages IDE configuration persistence
- * Saves and loads IDE-specific configurations to/from xiaoma/_config/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, '_config', '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 || {},
-    };
-
-    // Clean the config to remove any non-serializable values (like functions)
-    const cleanConfig = structuredClone(configData);
-
-    const yamlContent = yaml.stringify(cleanConfig, {
-      indent: 2,
-      lineWidth: 0,
-      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.parse(content);
-      return config;
-    } catch (error) {
-      await prompts.log.warn(`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) {
-      await prompts.log.warn(`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 };