bmad-method 5.0.0 → 5.1.0

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

@@ -1,31 +1,26 @@
-const fs = require("fs-extra");
-const path = require("path");
-const crypto = require("crypto");
-const glob = require("glob");
-
-// Dynamic import for ES module
-let chalk;
-
-// Initialize ES modules
-async function initializeModules() {
-  if (!chalk) {
-    chalk = (await import("chalk")).default;
-  }
-}
+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() {
-    this.manifestDir = ".bmad-core";
-    this.manifestFile = "install-manifest.yml";
-  }
+  constructor() {}
 
   async copyFile(source, destination) {
     try {
       await fs.ensureDir(path.dirname(destination));
-      await fs.copy(source, 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) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy ${source}:`), error.message);
       return false;
     }
@@ -34,27 +29,46 @@ class FileManager {
   async copyDirectory(source, destination) {
     try {
       await fs.ensureDir(destination);
-      await fs.copy(source, 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) {
-      await initializeModules();
-      console.error(
-        chalk.red(`Failed to copy directory ${source}:`),
-        error.message
-      );
+      console.error(chalk.red(`Failed to copy directory ${source}:`), error.message);
       return false;
     }
   }
 
-  async copyGlobPattern(pattern, sourceDir, destDir) {
-    const files = glob.sync(pattern, { cwd: sourceDir });
+  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);
+      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 (await this.copyFile(sourcePath, destPath)) {
+      if (success) {
         copied.push(file);
       }
     }
@@ -64,31 +78,40 @@ class FileManager {
 
   async calculateFileHash(filePath) {
     try {
-      const content = await fs.readFile(filePath);
-      return crypto
-        .createHash("sha256")
-        .update(content)
-        .digest("hex")
-        .slice(0, 16);
-    } catch (error) {
+      // 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
-    );
+    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: require("../../../package.json").version,
+      version: coreVersion,
       installed_at: new Date().toISOString(),
       install_type: config.installType,
       agent: config.agent || null,
-      ide_setup: config.ide || null,
       ides_setup: config.ides || [],
+      expansion_packs: config.expansionPacks || [],
       files: [],
     };
 
@@ -106,22 +129,29 @@ class FileManager {
 
     // Write manifest
     await fs.ensureDir(path.dirname(manifestPath));
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+    await fs.writeFile(manifestPath, yaml.dump(manifest, { indent: 2 }));
 
     return manifest;
   }
 
   async readManifest(installDir) {
-    const manifestPath = path.join(
-      installDir,
-      this.manifestDir,
-      this.manifestFile
-    );
+    const manifestPath = path.join(installDir, this.manifestDir, this.manifestFile);
 
     try {
-      const content = await fs.readFile(manifestPath, "utf8");
-      return JSON.parse(content);
-    } catch (error) {
+      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;
     }
   }
@@ -141,8 +171,35 @@ class FileManager {
     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";
+    const backupPath = filePath + '.bak';
     let counter = 1;
     let finalBackupPath = backupPath;
 
@@ -170,7 +227,7 @@ class FileManager {
   }
 
   async readFile(filePath) {
-    return fs.readFile(filePath, "utf8");
+    return fs.readFile(filePath, 'utf8');
   }
 
   async writeFile(filePath, content) {
@@ -181,6 +238,152 @@ class FileManager {
   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, '.bmad-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 = '.bmad-core';
+  manifestFile = 'install-manifest.yaml';
 }
 
 module.exports = new FileManager();

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

@@ -0,0 +1,228 @@
+/**
+ * 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, '.bmad-core', 'agents'),
+      path.join(installDir, 'bmad-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, '.bmad-core', 'agents', `${agentId}.md`),
+        path.join(installDir, 'bmad-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 !== '.bmad-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 !== '.bmad-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;