@zeyue0329/xiaoma-cli 1.13.0 → 1.15.1

package/tools/cli/lib/config.js

@@ -1,213 +0,0 @@
-const fs = require('fs-extra');
-const yaml = require('yaml');
-const path = require('node:path');
-const packageJson = require('../../../package.json');
-
-/**
- * Configuration utility class
- */
-class Config {
-  /**
-   * Load a YAML configuration file
-   * @param {string} configPath - Path to config file
-   * @returns {Object} Parsed configuration
-   */
-  async loadYaml(configPath) {
-    if (!(await fs.pathExists(configPath))) {
-      throw new Error(`Configuration file not found: ${configPath}`);
-    }
-
-    const content = await fs.readFile(configPath, 'utf8');
-    return yaml.parse(content);
-  }
-
-  /**
-   * Save configuration to YAML file
-   * @param {string} configPath - Path to config file
-   * @param {Object} config - Configuration object
-   */
-  async saveYaml(configPath, config) {
-    const yamlContent = yaml.dump(config, {
-      indent: 2,
-      lineWidth: 120,
-      noRefs: true,
-    });
-
-    await fs.ensureDir(path.dirname(configPath));
-    // Ensure POSIX-compliant final newline
-    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
-    await fs.writeFile(configPath, content, 'utf8');
-  }
-
-  /**
-   * Process configuration file (replace placeholders)
-   * @param {string} configPath - Path to config file
-   * @param {Object} replacements - Replacement values
-   */
-  async processConfig(configPath, replacements = {}) {
-    let content = await fs.readFile(configPath, 'utf8');
-
-    // Standard replacements
-    const standardReplacements = {
-      '{project-root}': replacements.root || '',
-      '{module}': replacements.module || '',
-      '{version}': replacements.version || packageJson.version,
-      '{date}': new Date().toISOString().split('T')[0],
-    };
-
-    // Apply all replacements
-    const allReplacements = { ...standardReplacements, ...replacements };
-
-    for (const [placeholder, value] of Object.entries(allReplacements)) {
-      if (typeof placeholder === 'string' && typeof value === 'string') {
-        const regex = new RegExp(placeholder.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`), 'g');
-        content = content.replace(regex, value);
-      }
-    }
-
-    await fs.writeFile(configPath, content, 'utf8');
-  }
-
-  /**
-   * Merge configurations
-   * @param {Object} base - Base configuration
-   * @param {Object} override - Override configuration
-   * @returns {Object} Merged configuration
-   */
-  mergeConfigs(base, override) {
-    return this.deepMerge(base, override);
-  }
-
-  /**
-   * Deep merge two objects
-   * @param {Object} target - Target object
-   * @param {Object} source - Source object
-   * @returns {Object} Merged object
-   */
-  deepMerge(target, source) {
-    const output = { ...target };
-
-    if (this.isObject(target) && this.isObject(source)) {
-      for (const key of Object.keys(source)) {
-        if (this.isObject(source[key])) {
-          if (key in target) {
-            output[key] = this.deepMerge(target[key], source[key]);
-          } else {
-            output[key] = source[key];
-          }
-        } else {
-          output[key] = source[key];
-        }
-      }
-    }
-
-    return output;
-  }
-
-  /**
-   * Check if value is an object
-   * @param {*} item - Item to check
-   * @returns {boolean} True if object
-   */
-  isObject(item) {
-    return item && typeof item === 'object' && !Array.isArray(item);
-  }
-
-  /**
-   * Validate configuration against schema
-   * @param {Object} config - Configuration to validate
-   * @param {Object} schema - Validation schema
-   * @returns {Object} Validation result
-   */
-  validateConfig(config, schema) {
-    const errors = [];
-    const warnings = [];
-
-    // Check required fields
-    if (schema.required) {
-      for (const field of schema.required) {
-        if (!(field in config)) {
-          errors.push(`Missing required field: ${field}`);
-        }
-      }
-    }
-
-    // Check field types
-    if (schema.properties) {
-      for (const [field, spec] of Object.entries(schema.properties)) {
-        if (field in config) {
-          const value = config[field];
-          const expectedType = spec.type;
-
-          if (expectedType === 'array' && !Array.isArray(value)) {
-            errors.push(`Field '${field}' should be an array`);
-          } else if (expectedType === 'object' && !this.isObject(value)) {
-            errors.push(`Field '${field}' should be an object`);
-          } else if (expectedType === 'string' && typeof value !== 'string') {
-            errors.push(`Field '${field}' should be a string`);
-          } else if (expectedType === 'number' && typeof value !== 'number') {
-            errors.push(`Field '${field}' should be a number`);
-          } else if (expectedType === 'boolean' && typeof value !== 'boolean') {
-            errors.push(`Field '${field}' should be a boolean`);
-          }
-
-          // Check enum values
-          if (spec.enum && !spec.enum.includes(value)) {
-            errors.push(`Field '${field}' must be one of: ${spec.enum.join(', ')}`);
-          }
-        }
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-    };
-  }
-
-  /**
-   * Get configuration value with fallback
-   * @param {Object} config - Configuration object
-   * @param {string} path - Dot-notation path to value
-   * @param {*} defaultValue - Default value if not found
-   * @returns {*} Configuration value
-   */
-  getValue(config, path, defaultValue = null) {
-    const keys = path.split('.');
-    let current = config;
-
-    for (const key of keys) {
-      if (current && typeof current === 'object' && key in current) {
-        current = current[key];
-      } else {
-        return defaultValue;
-      }
-    }
-
-    return current;
-  }
-
-  /**
-   * Set configuration value
-   * @param {Object} config - Configuration object
-   * @param {string} path - Dot-notation path to value
-   * @param {*} value - Value to set
-   */
-  setValue(config, path, value) {
-    const keys = path.split('.');
-    const lastKey = keys.pop();
-    let current = config;
-
-    for (const key of keys) {
-      if (!(key in current) || typeof current[key] !== 'object') {
-        current[key] = {};
-      }
-      current = current[key];
-    }
-
-    current[lastKey] = value;
-  }
-}
-
-module.exports = { Config };

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

@@ -1,116 +0,0 @@
-const fs = require('fs-extra');
-const path = require('node:path');
-const yaml = require('yaml');
-const { getProjectRoot } = require('./project-root');
-
-/**
- * Platform Codes Manager
- * Loads and provides access to the centralized platform codes configuration
- */
-class PlatformCodes {
-  constructor() {
-    this.configPath = path.join(getProjectRoot(), 'tools', 'platform-codes.yaml');
-    this.loadConfig();
-  }
-
-  /**
-   * Load the platform codes configuration
-   */
-  loadConfig() {
-    try {
-      if (fs.existsSync(this.configPath)) {
-        const content = fs.readFileSync(this.configPath, 'utf8');
-        this.config = yaml.parse(content);
-      } else {
-        console.warn(`Platform codes config not found at ${this.configPath}`);
-        this.config = { platforms: {} };
-      }
-    } catch (error) {
-      console.error(`Error loading platform codes: ${error.message}`);
-      this.config = { platforms: {} };
-    }
-  }
-
-  /**
-   * Get all platform codes
-   * @returns {Object} All platform configurations
-   */
-  getAllPlatforms() {
-    return this.config.platforms || {};
-  }
-
-  /**
-   * Get a specific platform configuration
-   * @param {string} code - Platform code
-   * @returns {Object|null} Platform configuration or null if not found
-   */
-  getPlatform(code) {
-    return this.config.platforms[code] || null;
-  }
-
-  /**
-   * Check if a platform code is valid
-   * @param {string} code - Platform code to validate
-   * @returns {boolean} True if valid
-   */
-  isValidPlatform(code) {
-    return code in this.config.platforms;
-  }
-
-  /**
-   * Get all preferred platforms
-   * @returns {Array} Array of preferred platform codes
-   */
-  getPreferredPlatforms() {
-    return Object.entries(this.config.platforms)
-      .filter(([, config]) => config.preferred)
-      .map(([code]) => code);
-  }
-
-  /**
-   * Get platforms by category
-   * @param {string} category - Category to filter by
-   * @returns {Array} Array of platform codes in the category
-   */
-  getPlatformsByCategory(category) {
-    return Object.entries(this.config.platforms)
-      .filter(([, config]) => config.category === category)
-      .map(([code]) => code);
-  }
-
-  /**
-   * Get platform display name
-   * @param {string} code - Platform code
-   * @returns {string} Display name or code if not found
-   */
-  getDisplayName(code) {
-    const platform = this.getPlatform(code);
-    return platform ? platform.name : code;
-  }
-
-  /**
-   * Validate platform code format
-   * @param {string} code - Platform code to validate
-   * @returns {boolean} True if format is valid
-   */
-  isValidFormat(code) {
-    const conventions = this.config.conventions || {};
-    const pattern = conventions.allowed_characters || 'a-z0-9-';
-    const maxLength = conventions.max_code_length || 20;
-
-    const regex = new RegExp(`^[${pattern}]+$`);
-    return regex.test(code) && code.length <= maxLength;
-  }
-
-  /**
-   * Get all platform codes as array
-   * @returns {Array} Array of platform codes
-   */
-  getCodes() {
-    return Object.keys(this.config.platforms);
-  }
-  config = null;
-}
-
-// Export singleton instance
-module.exports = new PlatformCodes();

package/tools/cli/lib/project-root.js

@@ -1,77 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-
-/**
- * Find the XiaoMa project root directory by looking for package.json
- * or specific XiaoMa markers
- */
-function findProjectRoot(startPath = __dirname) {
-  let currentPath = path.resolve(startPath);
-
-  // Keep going up until we find package.json with xiaoma-cli
-  while (currentPath !== path.dirname(currentPath)) {
-    const packagePath = path.join(currentPath, 'package.json');
-
-    if (fs.existsSync(packagePath)) {
-      try {
-        const pkg = fs.readJsonSync(packagePath);
-        // Check if this is the XiaoMa project
-        if (pkg.name === 'xiaoma-cli' || fs.existsSync(path.join(currentPath, 'src', 'core'))) {
-          return currentPath;
-        }
-      } catch {
-        // Continue searching
-      }
-    }
-
-    // Also check for src/core as a marker
-    if (fs.existsSync(path.join(currentPath, 'src', 'core', 'agents'))) {
-      return currentPath;
-    }
-
-    currentPath = path.dirname(currentPath);
-  }
-
-  // If we can't find it, use process.cwd() as fallback
-  return process.cwd();
-}
-
-// Cache the project root after first calculation
-let cachedRoot = null;
-
-function getProjectRoot() {
-  if (!cachedRoot) {
-    cachedRoot = findProjectRoot();
-  }
-  return cachedRoot;
-}
-
-/**
- * Get path to source directory
- */
-function getSourcePath(...segments) {
-  return path.join(getProjectRoot(), 'src', ...segments);
-}
-
-/**
- * Get path to a module's directory
- * xmc is a built-in module directly under src/
- * core is also directly under src/
- * All other modules are stored remote
- */
-function getModulePath(moduleName, ...segments) {
-  if (moduleName === 'core') {
-    return getSourcePath('core', ...segments);
-  }
-  if (moduleName === 'xmc') {
-    return getSourcePath('xmc', ...segments);
-  }
-  return getSourcePath('modules', moduleName, ...segments);
-}
-
-module.exports = {
-  getProjectRoot,
-  getSourcePath,
-  getModulePath,
-  findProjectRoot,
-};