@zeyue0329/xiaoma-cli 1.0.0

package/tools/installer/lib/config-loader.js

@@ -0,0 +1,253 @@
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const { extractYamlFromAgent } = require('../../lib/yaml-utils');
+
+class ConfigLoader {
+  constructor() {
+    this.configPath = path.join(__dirname, '..', 'config', 'install.config.yaml');
+    this.config = null;
+  }
+
+  async load() {
+    if (this.config) return this.config;
+    
+    try {
+      const configContent = await fs.readFile(this.configPath, 'utf8');
+      this.config = yaml.load(configContent);
+      return this.config;
+    } catch (error) {
+      throw new Error(`Failed to load configuration: ${error.message}`);
+    }
+  }
+
+  async getInstallationOptions() {
+    const config = await this.load();
+    return config['installation-options'] || {};
+  }
+
+  async getAvailableAgents() {
+    const agentsDir = path.join(this.getBmadCorePath(), 'agents');
+    
+    try {
+      const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+      const agents = [];
+      
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+          const agentPath = path.join(agentsDir, entry.name);
+          const agentId = path.basename(entry.name, '.md');
+          
+          try {
+            const agentContent = await fs.readFile(agentPath, 'utf8');
+            
+            // Extract YAML block from agent file
+            const yamlContentText = extractYamlFromAgent(agentContent);
+            if (yamlContentText) {
+              const yamlContent = yaml.load(yamlContentText);
+              const agentConfig = yamlContent.agent || {};
+              
+              agents.push({
+                id: agentId,
+                name: agentConfig.title || agentConfig.name || agentId,
+                file: `xiaoma-core/agents/${entry.name}`,
+                description: agentConfig.whenToUse || 'No description available'
+              });
+            }
+          } catch (error) {
+            console.warn(`Failed to read agent ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+      
+      // Sort agents by name for consistent display
+      agents.sort((a, b) => a.name.localeCompare(b.name));
+      
+      return agents;
+    } catch (error) {
+      console.warn(`Failed to read agents directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  async getAvailableExpansionPacks() {
+    const expansionPacksDir = path.join(this.getBmadCorePath(), '..', 'expansion-packs');
+    
+    try {
+      const entries = await fs.readdir(expansionPacksDir, { withFileTypes: true });
+      const expansionPacks = [];
+      
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          const packPath = path.join(expansionPacksDir, entry.name);
+          const configPath = path.join(packPath, 'config.yaml');
+          
+          try {
+            // Read config.yaml
+            const configContent = await fs.readFile(configPath, 'utf8');
+            const config = yaml.load(configContent);
+            
+            expansionPacks.push({
+              id: entry.name,
+              name: config.name || entry.name,
+              description: config['short-title'] || config.description || 'No description available',
+              fullDescription: config.description || config['short-title'] || 'No description available',
+              version: config.version || '1.0.0',
+              author: config.author || 'XiaoMa Team',
+              packPath: packPath,
+              dependencies: config.dependencies?.agents || []
+            });
+          } catch (error) {
+            // Fallback if config.yaml doesn't exist or can't be read
+            console.warn(`Failed to read config for expansion pack ${entry.name}: ${error.message}`);
+            
+            // Try to derive info from directory name as fallback
+            const name = entry.name
+              .split('-')
+              .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+              .join(' ');
+            
+            expansionPacks.push({
+              id: entry.name,
+              name: name,
+              description: 'No description available',
+              fullDescription: 'No description available',
+              version: '1.0.0',
+              author: 'XiaoMa Team',
+              packPath: packPath,
+              dependencies: []
+            });
+          }
+        }
+      }
+      
+      return expansionPacks;
+    } catch (error) {
+      console.warn(`Failed to read expansion packs directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  async getAgentDependencies(agentId) {
+    // Use DependencyResolver to dynamically parse agent dependencies
+    const DependencyResolver = require('../../lib/dependency-resolver');
+    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
+    
+    const agentDeps = await resolver.resolveAgentDependencies(agentId);
+    
+    // Convert to flat list of file paths
+    const depPaths = [];
+    
+    // Core files and utilities are included automatically by DependencyResolver
+    
+    // Add agent file itself is already handled by installer
+    
+    // Add all resolved resources
+    for (const resource of agentDeps.resources) {
+      const filePath = `.xiaoma-core/${resource.type}/${resource.id}.md`;
+      if (!depPaths.includes(filePath)) {
+        depPaths.push(filePath);
+      }
+    }
+    
+    return depPaths;
+  }
+
+  async getIdeConfiguration(ide) {
+    const config = await this.load();
+    const ideConfigs = config['ide-configurations'] || {};
+    return ideConfigs[ide] || null;
+  }
+
+  getBmadCorePath() {
+    // Get the path to xiaoma-core relative to the installer (now under tools)
+    return path.join(__dirname, '..', '..', '..', 'xiaoma-core');
+  }
+
+  getDistPath() {
+    // Get the path to dist directory relative to the installer
+    return path.join(__dirname, '..', '..', '..', 'dist');
+  }
+
+  getAgentPath(agentId) {
+    return path.join(this.getBmadCorePath(), 'agents', `${agentId}.md`);
+  }
+
+  async getAvailableTeams() {
+    const teamsDir = path.join(this.getBmadCorePath(), 'agent-teams');
+    
+    try {
+      const entries = await fs.readdir(teamsDir, { withFileTypes: true });
+      const teams = [];
+      
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.yaml')) {
+          const teamPath = path.join(teamsDir, entry.name);
+          
+          try {
+            const teamContent = await fs.readFile(teamPath, 'utf8');
+            const teamConfig = yaml.load(teamContent);
+            
+            if (teamConfig.bundle) {
+              teams.push({
+                id: path.basename(entry.name, '.yaml'),
+                name: teamConfig.bundle.name || entry.name,
+                description: teamConfig.bundle.description || 'Team configuration',
+                icon: teamConfig.bundle.icon || '📋'
+              });
+            }
+          } catch (error) {
+            console.warn(`Warning: Could not load team config ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+      
+      return teams;
+    } catch (error) {
+      console.warn(`Warning: Could not scan teams directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  getTeamPath(teamId) {
+    return path.join(this.getBmadCorePath(), 'agent-teams', `${teamId}.yaml`);
+  }
+
+  async getTeamDependencies(teamId) {
+    // Use DependencyResolver to dynamically parse team dependencies
+    const DependencyResolver = require('../../lib/dependency-resolver');
+    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
+    
+    try {
+      const teamDeps = await resolver.resolveTeamDependencies(teamId);
+      
+      // Convert to flat list of file paths
+      const depPaths = [];
+      
+      // Add team config file
+      depPaths.push(`.xiaoma-core/agent-teams/${teamId}.yaml`);
+      
+      // Add all agents
+      for (const agent of teamDeps.agents) {
+        const filePath = `.xiaoma-core/agents/${agent.id}.md`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
+        }
+      }
+      
+      // Add all resolved resources
+      for (const resource of teamDeps.resources) {
+        const filePath = `.xiaoma-core/${resource.type}/${resource.id}.${resource.type === 'workflows' ? 'yaml' : 'md'}`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
+        }
+      }
+      
+      return depPaths;
+    } catch (error) {
+      throw new Error(`Failed to resolve team dependencies for ${teamId}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = new ConfigLoader();

package/tools/installer/lib/file-manager.js

@@ -0,0 +1,411 @@
+const fs = require("fs-extra");
+const path = require("path");
+const crypto = require("crypto");
+const yaml = require("js-yaml");
+const chalk = require("chalk");
+const { createReadStream, createWriteStream, promises: fsPromises } = require('fs');
+const { pipeline } = require('stream/promises');
+const resourceLocator = require('./resource-locator');
+
+class FileManager {
+  constructor() {
+    this.manifestDir = ".xiaoma-core";
+    this.manifestFile = "install-manifest.yaml";
+  }
+
+  async copyFile(source, destination) {
+    try {
+      await fs.ensureDir(path.dirname(destination));
+      
+      // Use streaming for large files (> 10MB)
+      const stats = await fs.stat(source);
+      if (stats.size > 10 * 1024 * 1024) {
+        await pipeline(
+          createReadStream(source),
+          createWriteStream(destination)
+        );
+      } else {
+        await fs.copy(source, destination);
+      }
+      return true;
+    } catch (error) {
+      console.error(chalk.red(`Failed to copy ${source}:`), error.message);
+      return false;
+    }
+  }
+
+  async copyDirectory(source, destination) {
+    try {
+      await fs.ensureDir(destination);
+      
+      // Use streaming copy for large directories
+      const files = await resourceLocator.findFiles('**/*', {
+        cwd: source,
+        nodir: true
+      });
+      
+      // Process files in batches to avoid memory issues
+      const batchSize = 50;
+      for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
+        await Promise.all(
+          batch.map(file => 
+            this.copyFile(
+              path.join(source, file),
+              path.join(destination, file)
+            )
+          )
+        );
+      }
+      return true;
+    } catch (error) {
+      console.error(
+        chalk.red(`Failed to copy directory ${source}:`),
+        error.message
+      );
+      return false;
+    }
+  }
+
+  async copyGlobPattern(pattern, sourceDir, destDir, rootValue = null) {
+    const files = await resourceLocator.findFiles(pattern, { cwd: sourceDir });
+    const copied = [];
+
+    for (const file of files) {
+      const sourcePath = path.join(sourceDir, file);
+      const destPath = path.join(destDir, file);
+
+      // Use root replacement if rootValue is provided and file needs it
+      const needsRootReplacement = rootValue && (file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml'));
+      
+      let success = false;
+      if (needsRootReplacement) {
+        success = await this.copyFileWithRootReplacement(sourcePath, destPath, rootValue);
+      } else {
+        success = await this.copyFile(sourcePath, destPath);
+      }
+
+      if (success) {
+        copied.push(file);
+      }
+    }
+
+    return copied;
+  }
+
+  async calculateFileHash(filePath) {
+    try {
+      // Use streaming for hash calculation to reduce memory usage
+      const stream = createReadStream(filePath);
+      const hash = crypto.createHash("sha256");
+      
+      for await (const chunk of stream) {
+        hash.update(chunk);
+      }
+      
+      return hash.digest("hex").slice(0, 16);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async createManifest(installDir, config, files) {
+    const manifestPath = path.join(
+      installDir,
+      this.manifestDir,
+      this.manifestFile
+    );
+
+    // Read version from package.json
+    let coreVersion = "unknown";
+    try {
+      const packagePath = path.join(__dirname, '..', '..', '..', 'package.json');
+      const packageJson = require(packagePath);
+      coreVersion = packageJson.version;
+    } catch (error) {
+      console.warn("Could not read version from package.json, using 'unknown'");
+    }
+
+    const manifest = {
+      version: coreVersion,
+      installed_at: new Date().toISOString(),
+      install_type: config.installType,
+      agent: config.agent || null,
+      ides_setup: config.ides || [],
+      expansion_packs: config.expansionPacks || [],
+      files: [],
+    };
+
+    // Add file information
+    for (const file of files) {
+      const filePath = path.join(installDir, file);
+      const hash = await this.calculateFileHash(filePath);
+
+      manifest.files.push({
+        path: file,
+        hash: hash,
+        modified: false,
+      });
+    }
+
+    // Write manifest
+    await fs.ensureDir(path.dirname(manifestPath));
+    await fs.writeFile(manifestPath, yaml.dump(manifest, { indent: 2 }));
+
+    return manifest;
+  }
+
+  async readManifest(installDir) {
+    const manifestPath = path.join(
+      installDir,
+      this.manifestDir,
+      this.manifestFile
+    );
+
+    try {
+      const content = await fs.readFile(manifestPath, "utf8");
+      return yaml.load(content);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async readExpansionPackManifest(installDir, packId) {
+    const manifestPath = path.join(
+      installDir,
+      `.${packId}`,
+      this.manifestFile
+    );
+
+    try {
+      const content = await fs.readFile(manifestPath, "utf8");
+      return yaml.load(content);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async checkModifiedFiles(installDir, manifest) {
+    const modified = [];
+
+    for (const file of manifest.files) {
+      const filePath = path.join(installDir, file.path);
+      const currentHash = await this.calculateFileHash(filePath);
+
+      if (currentHash && currentHash !== file.hash) {
+        modified.push(file.path);
+      }
+    }
+
+    return modified;
+  }
+
+  async checkFileIntegrity(installDir, manifest) {
+    const result = {
+      missing: [],
+      modified: []
+    };
+
+    for (const file of manifest.files) {
+      const filePath = path.join(installDir, file.path);
+      
+      // Skip checking the manifest file itself - it will always be different due to timestamps
+      if (file.path.endsWith('install-manifest.yaml')) {
+        continue;
+      }
+      
+      if (!(await this.pathExists(filePath))) {
+        result.missing.push(file.path);
+      } else {
+        const currentHash = await this.calculateFileHash(filePath);
+        if (currentHash && currentHash !== file.hash) {
+          result.modified.push(file.path);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  async backupFile(filePath) {
+    const backupPath = filePath + ".bak";
+    let counter = 1;
+    let finalBackupPath = backupPath;
+
+    // Find a unique backup filename
+    while (await fs.pathExists(finalBackupPath)) {
+      finalBackupPath = `${filePath}.bak${counter}`;
+      counter++;
+    }
+
+    await fs.copy(filePath, finalBackupPath);
+    return finalBackupPath;
+  }
+
+  async ensureDirectory(dirPath) {
+    try {
+      await fs.ensureDir(dirPath);
+      return true;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async pathExists(filePath) {
+    return fs.pathExists(filePath);
+  }
+
+  async readFile(filePath) {
+    return fs.readFile(filePath, "utf8");
+  }
+
+  async writeFile(filePath, content) {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+  }
+
+  async removeDirectory(dirPath) {
+    await fs.remove(dirPath);
+  }
+
+  async createExpansionPackManifest(installDir, packId, config, files) {
+    const manifestPath = path.join(
+      installDir,
+      `.${packId}`,
+      this.manifestFile
+    );
+
+    const manifest = {
+      version: config.expansionPackVersion || require("../../../package.json").version,
+      installed_at: new Date().toISOString(),
+      install_type: config.installType,
+      expansion_pack_id: config.expansionPackId,
+      expansion_pack_name: config.expansionPackName,
+      ides_setup: config.ides || [],
+      files: [],
+    };
+
+    // Add file information
+    for (const file of files) {
+      const filePath = path.join(installDir, file);
+      const hash = await this.calculateFileHash(filePath);
+
+      manifest.files.push({
+        path: file,
+        hash: hash,
+        modified: false,
+      });
+    }
+
+    // Write manifest
+    await fs.ensureDir(path.dirname(manifestPath));
+    await fs.writeFile(manifestPath, yaml.dump(manifest, { indent: 2 }));
+
+    return manifest;
+  }
+
+  async modifyCoreConfig(installDir, config) {
+    const coreConfigPath = path.join(installDir, '.xiaoma-core', 'core-config.yaml');
+    
+    try {
+      // Read the existing core-config.yaml
+      const coreConfigContent = await fs.readFile(coreConfigPath, 'utf8');
+      const coreConfig = yaml.load(coreConfigContent);
+      
+      // Modify sharding settings if provided
+      if (config.prdSharded !== undefined) {
+        coreConfig.prd.prdSharded = config.prdSharded;
+      }
+      
+      if (config.architectureSharded !== undefined) {
+        coreConfig.architecture.architectureSharded = config.architectureSharded;
+      }
+      
+      // Write back the modified config
+      await fs.writeFile(coreConfigPath, yaml.dump(coreConfig, { indent: 2 }));
+      
+      return true;
+    } catch (error) {
+      console.error(chalk.red(`Failed to modify core-config.yaml:`), error.message);
+      return false;
+    }
+  }
+
+  async copyFileWithRootReplacement(source, destination, rootValue) {
+    try {
+      // Check file size to determine if we should stream
+      const stats = await fs.stat(source);
+      
+      if (stats.size > 5 * 1024 * 1024) { // 5MB threshold
+        // Use streaming for large files
+        const { Transform } = require('stream');
+        const replaceStream = new Transform({
+          transform(chunk, encoding, callback) {
+            const modified = chunk.toString().replace(/\{root\}/g, rootValue);
+            callback(null, modified);
+          }
+        });
+        
+        await this.ensureDirectory(path.dirname(destination));
+        await pipeline(
+          createReadStream(source, { encoding: 'utf8' }),
+          replaceStream,
+          createWriteStream(destination, { encoding: 'utf8' })
+        );
+      } else {
+        // Regular approach for smaller files
+        const content = await fsPromises.readFile(source, 'utf8');
+        const updatedContent = content.replace(/\{root\}/g, rootValue);
+        await this.ensureDirectory(path.dirname(destination));
+        await fsPromises.writeFile(destination, updatedContent, 'utf8');
+      }
+      
+      return true;
+    } catch (error) {
+      console.error(chalk.red(`Failed to copy ${source} with root replacement:`), error.message);
+      return false;
+    }
+  }
+
+  async copyDirectoryWithRootReplacement(source, destination, rootValue, fileExtensions = ['.md', '.yaml', '.yml']) {
+    try {
+      await this.ensureDirectory(destination);
+      
+      // Get all files in source directory
+      const files = await resourceLocator.findFiles('**/*', { 
+        cwd: source, 
+        nodir: true 
+      });
+      
+      let replacedCount = 0;
+      
+      for (const file of files) {
+        const sourcePath = path.join(source, file);
+        const destPath = path.join(destination, file);
+        
+        // Check if this file type should have {root} replacement
+        const shouldReplace = fileExtensions.some(ext => file.endsWith(ext));
+        
+        if (shouldReplace) {
+          if (await this.copyFileWithRootReplacement(sourcePath, destPath, rootValue)) {
+            replacedCount++;
+          }
+        } else {
+          // Regular copy for files that don't need replacement
+          await this.copyFile(sourcePath, destPath);
+        }
+      }
+      
+      if (replacedCount > 0) {
+        console.log(chalk.dim(`  Processed ${replacedCount} files with {root} replacement`));
+      }
+      
+      return true;
+    } catch (error) {
+      console.error(chalk.red(`Failed to copy directory ${source} with root replacement:`), error.message);
+      return false;
+    }
+  }
+}
+
+module.exports = new FileManager();