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

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

@@ -1,446 +0,0 @@
-const fs = require("fs-extra");
-const path = require("node:path");
-const crypto = require("node:crypto");
-const yaml = require("js-yaml");
-const chalk = require("chalk");
-const {
-  createReadStream,
-  createWriteStream,
-  promises: fsPromises,
-} = require("node:fs");
-const { pipeline } = require("node:stream/promises");
-const resourceLocator = require("./resource-locator");
-
-class FileManager {
-  constructor() {}
-
-  async copyFile(source, destination) {
-    try {
-      await fs.ensureDir(path.dirname(destination));
-
-      // Use streaming for large files (> 10MB)
-      const stats = await fs.stat(source);
-      await (stats.size > 10 * 1024 * 1024
-        ? pipeline(createReadStream(source), createWriteStream(destination))
-        : 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 index = 0; index < files.length; index += batchSize) {
-        const batch = files.slice(index, index + 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 destinationPath = 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;
-      success = await (needsRootReplacement
-        ? this.copyFileWithRootReplacement(
-            sourcePath,
-            destinationPath,
-            rootValue,
-          )
-        : this.copyFile(sourcePath, destinationPath));
-
-      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 {
-      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 {
-      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 {
-      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 {
-      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)) {
-        const currentHash = await this.calculateFileHash(filePath);
-        if (currentHash && currentHash !== file.hash) {
-          result.modified.push(file.path);
-        }
-      } else {
-        result.missing.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("node:stream");
-        const replaceStream = new Transform({
-          transform(chunk, encoding, callback) {
-            const modified = chunk.toString().replaceAll("{root}", 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.replaceAll("{root}", 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 destinationPath = path.join(destination, file);
-
-        // Check if this file type should have {root} replacement
-        const shouldReplace = fileExtensions.some((extension) =>
-          file.endsWith(extension),
-        );
-
-        if (shouldReplace) {
-          if (
-            await this.copyFileWithRootReplacement(
-              sourcePath,
-              destinationPath,
-              rootValue,
-            )
-          ) {
-            replacedCount++;
-          }
-        } else {
-          // Regular copy for files that don't need replacement
-          await this.copyFile(sourcePath, destinationPath);
-        }
-      }
-
-      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;
-    }
-  }
-  manifestDir = ".xiaoma-core";
-  manifestFile = "install-manifest.yaml";
-}
-
-module.exports = new FileManager();

package/tools/installer/lib/ide-base-setup.js

@@ -1,238 +0,0 @@
-/**
- * Base IDE Setup - Common functionality for all IDE setups
- * Reduces duplication and provides shared methods
- */
-
-const path = require("node:path");
-const fs = require("fs-extra");
-const yaml = require("js-yaml");
-const chalk = require("chalk").default || require("chalk");
-const fileManager = require("./file-manager");
-const resourceLocator = require("./resource-locator");
-const { extractYamlFromAgent } = require("../../lib/yaml-utils");
-
-class BaseIdeSetup {
-  constructor() {
-    this._agentCache = new Map();
-    this._pathCache = new Map();
-  }
-
-  /**
-   * Get all agent IDs with caching
-   */
-  async getAllAgentIds(installDir) {
-    const cacheKey = `all-agents:${installDir}`;
-    if (this._agentCache.has(cacheKey)) {
-      return this._agentCache.get(cacheKey);
-    }
-
-    const allAgents = new Set();
-
-    // Get core agents
-    const coreAgents = await this.getCoreAgentIds(installDir);
-    for (const id of coreAgents) allAgents.add(id);
-
-    // Get expansion pack agents
-    const expansionPacks = await this.getInstalledExpansionPacks(installDir);
-    for (const pack of expansionPacks) {
-      const packAgents = await this.getExpansionPackAgents(pack.path);
-      for (const id of packAgents) allAgents.add(id);
-    }
-
-    const result = [...allAgents];
-    this._agentCache.set(cacheKey, result);
-    return result;
-  }
-
-  /**
-   * Get core agent IDs
-   */
-  async getCoreAgentIds(installDir) {
-    const coreAgents = [];
-    const corePaths = [
-      path.join(installDir, ".xiaoma-core", "agents"),
-      path.join(installDir, "xiaoma-core", "agents"),
-    ];
-
-    for (const agentsDir of corePaths) {
-      if (await fileManager.pathExists(agentsDir)) {
-        const files = await resourceLocator.findFiles("*.md", {
-          cwd: agentsDir,
-        });
-        coreAgents.push(...files.map((file) => path.basename(file, ".md")));
-        break; // Use first found
-      }
-    }
-
-    return coreAgents;
-  }
-
-  /**
-   * Find agent path with caching
-   */
-  async findAgentPath(agentId, installDir) {
-    const cacheKey = `agent-path:${agentId}:${installDir}`;
-    if (this._pathCache.has(cacheKey)) {
-      return this._pathCache.get(cacheKey);
-    }
-
-    // Use resource locator for efficient path finding
-    let agentPath = await resourceLocator.getAgentPath(agentId);
-
-    if (!agentPath) {
-      // Check installation-specific paths
-      const possiblePaths = [
-        path.join(installDir, ".xiaoma-core", "agents", `${agentId}.md`),
-        path.join(installDir, "xiaoma-core", "agents", `${agentId}.md`),
-        path.join(installDir, "common", "agents", `${agentId}.md`),
-      ];
-
-      for (const testPath of possiblePaths) {
-        if (await fileManager.pathExists(testPath)) {
-          agentPath = testPath;
-          break;
-        }
-      }
-    }
-
-    if (agentPath) {
-      this._pathCache.set(cacheKey, agentPath);
-    }
-    return agentPath;
-  }
-
-  /**
-   * Get agent title from metadata
-   */
-  async getAgentTitle(agentId, installDir) {
-    const agentPath = await this.findAgentPath(agentId, installDir);
-    if (!agentPath) return agentId;
-
-    try {
-      const content = await fileManager.readFile(agentPath);
-      const yamlContent = extractYamlFromAgent(content);
-      if (yamlContent) {
-        const metadata = yaml.load(yamlContent);
-        return metadata.agent_name || agentId;
-      }
-    } catch {
-      // Fallback to agent ID
-    }
-    return agentId;
-  }
-
-  /**
-   * Get installed expansion packs
-   */
-  async getInstalledExpansionPacks(installDir) {
-    const cacheKey = `expansion-packs:${installDir}`;
-    if (this._pathCache.has(cacheKey)) {
-      return this._pathCache.get(cacheKey);
-    }
-
-    const expansionPacks = [];
-
-    // Check for dot-prefixed expansion packs
-    const dotExpansions = await resourceLocator.findFiles(".bmad-*", {
-      cwd: installDir,
-    });
-
-    for (const dotExpansion of dotExpansions) {
-      if (dotExpansion !== ".xiaoma-core") {
-        const packPath = path.join(installDir, dotExpansion);
-        const packName = dotExpansion.slice(1); // remove the dot
-        expansionPacks.push({
-          name: packName,
-          path: packPath,
-        });
-      }
-    }
-
-    // Check other dot folders that have config.yaml
-    const allDotFolders = await resourceLocator.findFiles(".*", {
-      cwd: installDir,
-    });
-    for (const folder of allDotFolders) {
-      if (!folder.startsWith(".bmad-") && folder !== ".xiaoma-core") {
-        const packPath = path.join(installDir, folder);
-        const configPath = path.join(packPath, "config.yaml");
-        if (await fileManager.pathExists(configPath)) {
-          expansionPacks.push({
-            name: folder.slice(1), // remove the dot
-            path: packPath,
-          });
-        }
-      }
-    }
-
-    this._pathCache.set(cacheKey, expansionPacks);
-    return expansionPacks;
-  }
-
-  /**
-   * Get expansion pack agents
-   */
-  async getExpansionPackAgents(packPath) {
-    const agentsDir = path.join(packPath, "agents");
-    if (!(await fileManager.pathExists(agentsDir))) {
-      return [];
-    }
-
-    const agentFiles = await resourceLocator.findFiles("*.md", {
-      cwd: agentsDir,
-    });
-    return agentFiles.map((file) => path.basename(file, ".md"));
-  }
-
-  /**
-   * Create agent rule content (shared logic)
-   */
-  async createAgentRuleContent(agentId, agentPath, installDir, format = "mdc") {
-    const agentContent = await fileManager.readFile(agentPath);
-    const agentTitle = await this.getAgentTitle(agentId, installDir);
-    const yamlContent = extractYamlFromAgent(agentContent);
-
-    let content = "";
-
-    if (format === "mdc") {
-      // MDC format for Cursor
-      content = "---\n";
-      content += "description: \n";
-      content += "globs: []\n";
-      content += "alwaysApply: false\n";
-      content += "---\n\n";
-      content += `# ${agentId.toUpperCase()} Agent Rule\n\n`;
-      content += `This rule is triggered when the user types \`@${agentId}\` and activates the ${agentTitle} agent persona.\n\n`;
-      content += "## Agent Activation\n\n";
-      content +=
-        "CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n";
-      content += "```yaml\n";
-      content += yamlContent || agentContent.replace(/^#.*$/m, "").trim();
-      content += "\n```\n\n";
-      content += "## File Reference\n\n";
-      const relativePath = path
-        .relative(installDir, agentPath)
-        .replaceAll("\\", "/");
-      content += `The complete agent definition is available in [${relativePath}](mdc:${relativePath}).\n\n`;
-      content += "## Usage\n\n";
-      content += `When the user types \`@${agentId}\`, activate this ${agentTitle} persona and follow all instructions defined in the YAML configuration above.\n`;
-    } else if (format === "claude") {
-      // Claude Code format
-      content = `# /${agentId} Command\n\n`;
-      content += `When this command is used, adopt the following agent persona:\n\n`;
-      content += agentContent;
-    }
-
-    return content;
-  }
-
-  /**
-   * Clear all caches
-   */
-  clearCache() {
-    this._agentCache.clear();
-    this._pathCache.clear();
-  }
-}
-
-module.exports = BaseIdeSetup;