bmad-method 4.30.2 → 4.30.4

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

@@ -1,18 +1,11 @@
 const fs = require("fs-extra");
 const path = require("path");
 const crypto = require("crypto");
-const glob = require("glob");
 const yaml = require("js-yaml");
-
-// Dynamic import for ES module
-let chalk;
-
-// Initialize ES modules
-async function initializeModules() {
-  if (!chalk) {
-    chalk = (await import("chalk")).default;
-  }
-}
+const chalk = require("chalk");
+const { createReadStream, createWriteStream, promises: fsPromises } = require('fs');
+const { pipeline } = require('stream/promises');
+const resourceLocator = require('./resource-locator');
 
 class FileManager {
   constructor() {
@@ -23,10 +16,19 @@ class FileManager {
   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);
+      if (stats.size > 10 * 1024 * 1024) {
+        await pipeline(
+          createReadStream(source),
+          createWriteStream(destination)
+        );
+      } else {
+        await fs.copy(source, destination);
+      }
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy ${source}:`), error.message);
       return false;
     }
@@ -35,10 +37,28 @@ 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 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) {
-      await initializeModules();
       console.error(
         chalk.red(`Failed to copy directory ${source}:`),
         error.message
@@ -48,7 +68,7 @@ class FileManager {
   }
 
   async copyGlobPattern(pattern, sourceDir, destDir, rootValue = null) {
-    const files = glob.sync(pattern, { cwd: sourceDir });
+    const files = await resourceLocator.findFiles(pattern, { cwd: sourceDir });
     const copied = [];
 
     for (const file of files) {
@@ -75,12 +95,15 @@ class FileManager {
 
   async calculateFileHash(filePath) {
     try {
-      const content = await fs.readFile(filePath);
-      return crypto
-        .createHash("sha256")
-        .update(content)
-        .digest("hex")
-        .slice(0, 16);
+      // 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;
     }
@@ -93,15 +116,14 @@ class FileManager {
       this.manifestFile
     );
 
-    // Read version from core-config.yaml
-    const coreConfigPath = path.join(__dirname, "../../../bmad-core/core-config.yaml");
+    // Read version from package.json
     let coreVersion = "unknown";
     try {
-      const coreConfigContent = await fs.readFile(coreConfigPath, "utf8");
-      const coreConfig = yaml.load(coreConfigContent);
-      coreVersion = coreConfig.version || "unknown";
+      const packagePath = path.join(__dirname, '..', '..', '..', 'package.json');
+      const packageJson = require(packagePath);
+      coreVersion = packageJson.version;
     } catch (error) {
-      console.warn("Could not read version from core-config.yaml, using 'unknown'");
+      console.warn("Could not read version from package.json, using 'unknown'");
     }
 
     const manifest = {
@@ -304,7 +326,6 @@ class FileManager {
       
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to modify core-config.yaml:`), error.message);
       return false;
     }
@@ -312,22 +333,35 @@ class FileManager {
 
   async copyFileWithRootReplacement(source, destination, rootValue) {
     try {
-      // Read the source file content
-      const fs = require('fs').promises;
-      const content = await fs.readFile(source, 'utf8');
-      
-      // Replace {root} with the specified root value
-      const updatedContent = content.replace(/\{root\}/g, rootValue);
+      // Check file size to determine if we should stream
+      const stats = await fs.stat(source);
       
-      // Ensure directory exists
-      await this.ensureDirectory(path.dirname(destination));
-      
-      // Write the updated content
-      await fs.writeFile(destination, updatedContent, 'utf8');
+      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) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy ${source} with root replacement:`), error.message);
       return false;
     }
@@ -335,11 +369,10 @@ class FileManager {
 
   async copyDirectoryWithRootReplacement(source, destination, rootValue, fileExtensions = ['.md', '.yaml', '.yml']) {
     try {
-      await initializeModules(); // Ensure chalk is initialized
       await this.ensureDirectory(destination);
       
       // Get all files in source directory
-      const files = glob.sync('**/*', { 
+      const files = await resourceLocator.findFiles('**/*', { 
         cwd: source, 
         nodir: true 
       });
@@ -369,7 +402,6 @@ class FileManager {
       
       return true;
     } catch (error) {
-      await initializeModules();
       console.error(chalk.red(`Failed to copy directory ${source} with root replacement:`), error.message);
       return false;
     }

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

@@ -0,0 +1,227 @@
+/**
+ * Base IDE Setup - Common functionality for all IDE setups
+ * Reduces duplication and provides shared methods
+ */
+
+const path = require("path");
+const fs = require("fs-extra");
+const yaml = require("js-yaml");
+const chalk = 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);
+    coreAgents.forEach(id => 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);
+      packAgents.forEach(id => allAgents.add(id));
+    }
+    
+    const result = Array.from(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 (error) {
+      // 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.substring(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.substring(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).replace(/\\/g, '/');
+      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;

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

@@ -1,26 +1,17 @@
 const path = require("path");
 const fs = require("fs-extra");
 const yaml = require("js-yaml");
+const chalk = require("chalk");
+const inquirer = require("inquirer");
 const fileManager = require("./file-manager");
 const configLoader = require("./config-loader");
 const { extractYamlFromAgent } = require("../../lib/yaml-utils");
+const BaseIdeSetup = require("./ide-base-setup");
+const resourceLocator = require("./resource-locator");
 
-// Dynamic import for ES module
-let chalk;
-let inquirer;
-
-// Initialize ES modules
-async function initializeModules() {
-  if (!chalk) {
-    chalk = (await import("chalk")).default;
-  }
-  if (!inquirer) {
-    inquirer = (await import("inquirer")).default;
-  }
-}
-
-class IdeSetup {
+class IdeSetup extends BaseIdeSetup {
   constructor() {
+    super();
     this.ideAgentConfig = null;
   }
 
@@ -42,7 +33,6 @@ class IdeSetup {
   }
 
   async setup(ide, installDir, selectedAgent = null, spinner = null, preConfiguredSettings = null) {
-    await initializeModules();
     const ideConfig = await configLoader.getIdeConfiguration(ide);
 
     if (!ideConfig) {
@@ -80,53 +70,17 @@ class IdeSetup {
     await fileManager.ensureDirectory(cursorRulesDir);
 
     for (const agentId of agents) {
-      // Find the agent file
       const agentPath = await this.findAgentPath(agentId, installDir);
 
       if (agentPath) {
-        const agentContent = await fileManager.readFile(agentPath);
+        const mdcContent = await this.createAgentRuleContent(agentId, agentPath, installDir, 'mdc');
         const mdcPath = path.join(cursorRulesDir, `${agentId}.mdc`);
-
-        // Create MDC content with proper format
-        let mdcContent = "---\n";
-        mdcContent += "description: \n";
-        mdcContent += "globs: []\n";
-        mdcContent += "alwaysApply: false\n";
-        mdcContent += "---\n\n";
-        mdcContent += `# ${agentId.toUpperCase()} Agent Rule\n\n`;
-        mdcContent += `This rule is triggered when the user types \`@${agentId}\` and activates the ${await this.getAgentTitle(
-          agentId,
-          installDir
-        )} agent persona.\n\n`;
-        mdcContent += "## Agent Activation\n\n";
-        mdcContent +=
-          "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";
-        mdcContent += "```yaml\n";
-        // Extract just the YAML content from the agent file
-        const yamlContent = extractYamlFromAgent(agentContent);
-        if (yamlContent) {
-          mdcContent += yamlContent;
-        } else {
-          // If no YAML found, include the whole content minus the header
-          mdcContent += agentContent.replace(/^#.*$/m, "").trim();
-        }
-        mdcContent += "\n```\n\n";
-        mdcContent += "## File Reference\n\n";
-        const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
-        mdcContent += `The complete agent definition is available in [${relativePath}](mdc:${relativePath}).\n\n`;
-        mdcContent += "## Usage\n\n";
-        mdcContent += `When the user types \`@${agentId}\`, activate this ${await this.getAgentTitle(
-          agentId,
-          installDir
-        )} persona and follow all instructions defined in the YAML configuration above.\n`;
-
         await fileManager.writeFile(mdcPath, mdcContent);
         console.log(chalk.green(`✓ Created rule: ${agentId}.mdc`));
       }
     }
 
     console.log(chalk.green(`\n✓ Created Cursor rules in ${cursorRulesDir}`));
-
     return true;
   }
 
@@ -827,7 +781,6 @@ class IdeSetup {
   }
 
   async setupGeminiCli(installDir) {
-    await initializeModules();
     const geminiDir = path.join(installDir, ".gemini");
     const bmadMethodDir = path.join(geminiDir, "bmad-method");
     await fileManager.ensureDirectory(bmadMethodDir);
@@ -928,8 +881,6 @@ class IdeSetup {
   }
 
   async setupGitHubCopilot(installDir, selectedAgent, spinner = null, preConfiguredSettings = null) {
-    await initializeModules();
-    
     // Configure VS Code workspace settings first to avoid UI conflicts with loading spinners
     await this.configureVsCodeSettings(installDir, spinner, preConfiguredSettings);
     
@@ -960,7 +911,7 @@ class IdeSetup {
         
         let chatmodeContent = `---
 description: "${description.replace(/"/g, '\\"')}"
-tools: ['changes', 'codebase', 'fetch', 'findTestFiles', 'githubRepo', 'problems', 'usages']
+tools: ['changes', 'codebase', 'fetch', 'findTestFiles', 'githubRepo', 'problems', 'usages', 'editFiles', 'runCommands', 'runTasks', 'runTests', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure']
 ---
 
 `;
@@ -978,7 +929,6 @@ tools: ['changes', 'codebase', 'fetch', 'findTestFiles', 'githubRepo', 'problems
   }
 
   async configureVsCodeSettings(installDir, spinner, preConfiguredSettings = null) {
-    await initializeModules(); // Ensure inquirer is loaded
     const vscodeDir = path.join(installDir, ".vscode");
     const settingsPath = path.join(vscodeDir, "settings.json");