bmad-method 4.37.0 → 4.39.0

package/tools/installer/lib/memory-profiler.js

@@ -3,7 +3,7 @@
  * Helps identify memory leaks and optimize resource usage
  */
 
-const v8 = require('v8');
+const v8 = require('node:v8');
 
 class MemoryProfiler {
   constructor() {
@@ -19,7 +19,7 @@ class MemoryProfiler {
   checkpoint(label) {
     const memUsage = process.memoryUsage();
     const heapStats = v8.getHeapStatistics();
-    
+
     const checkpoint = {
       label,
       timestamp: Date.now() - this.startTime,
@@ -28,18 +28,18 @@ class MemoryProfiler {
         heapTotal: this.formatBytes(memUsage.heapTotal),
         heapUsed: this.formatBytes(memUsage.heapUsed),
         external: this.formatBytes(memUsage.external),
-        arrayBuffers: this.formatBytes(memUsage.arrayBuffers || 0)
+        arrayBuffers: this.formatBytes(memUsage.arrayBuffers || 0),
       },
       heap: {
         totalHeapSize: this.formatBytes(heapStats.total_heap_size),
         usedHeapSize: this.formatBytes(heapStats.used_heap_size),
         heapSizeLimit: this.formatBytes(heapStats.heap_size_limit),
         mallocedMemory: this.formatBytes(heapStats.malloced_memory),
-        externalMemory: this.formatBytes(heapStats.external_memory)
+        externalMemory: this.formatBytes(heapStats.external_memory),
       },
       raw: {
-        heapUsed: memUsage.heapUsed
-      }
+        heapUsed: memUsage.heapUsed,
+      },
     };
 
     // Track peak memory
@@ -55,8 +55,8 @@ class MemoryProfiler {
    * Force garbage collection (requires --expose-gc flag)
    */
   forceGC() {
-    if (global.gc) {
-      global.gc();
+    if (globalThis.gc) {
+      globalThis.gc();
       return true;
     }
     return false;
@@ -67,16 +67,16 @@ class MemoryProfiler {
    */
   getSummary() {
     const currentMemory = process.memoryUsage();
-    
+
     return {
       currentUsage: {
         rss: this.formatBytes(currentMemory.rss),
         heapTotal: this.formatBytes(currentMemory.heapTotal),
-        heapUsed: this.formatBytes(currentMemory.heapUsed)
+        heapUsed: this.formatBytes(currentMemory.heapUsed),
       },
       peakMemory: this.formatBytes(this.peakMemory),
       totalCheckpoints: this.checkpoints.length,
-      runTime: `${((Date.now() - this.startTime) / 1000).toFixed(2)}s`
+      runTime: `${((Date.now() - this.startTime) / 1000).toFixed(2)}s`,
     };
   }
 
@@ -86,12 +86,12 @@ class MemoryProfiler {
   getDetailedReport() {
     const summary = this.getSummary();
     const memoryGrowth = this.calculateMemoryGrowth();
-    
+
     return {
       summary,
       memoryGrowth,
       checkpoints: this.checkpoints,
-      recommendations: this.getRecommendations(memoryGrowth)
+      recommendations: this.getRecommendations(memoryGrowth),
     };
   }
 
@@ -100,23 +100,23 @@ class MemoryProfiler {
    */
   calculateMemoryGrowth() {
     if (this.checkpoints.length < 2) return [];
-    
+
     const growth = [];
-    for (let i = 1; i < this.checkpoints.length; i++) {
-      const prev = this.checkpoints[i - 1];
-      const curr = this.checkpoints[i];
-      
-      const heapDiff = curr.raw.heapUsed - prev.raw.heapUsed;
-      
+    for (let index = 1; index < this.checkpoints.length; index++) {
+      const previous = this.checkpoints[index - 1];
+      const current = this.checkpoints[index];
+
+      const heapDiff = current.raw.heapUsed - previous.raw.heapUsed;
+
       growth.push({
-        from: prev.label,
-        to: curr.label,
+        from: previous.label,
+        to: current.label,
         heapGrowth: this.formatBytes(Math.abs(heapDiff)),
         isIncrease: heapDiff > 0,
-        timeDiff: `${((curr.timestamp - prev.timestamp) / 1000).toFixed(2)}s`
+        timeDiff: `${((current.timestamp - previous.timestamp) / 1000).toFixed(2)}s`,
       });
     }
-    
+
     return growth;
   }
 
@@ -125,40 +125,41 @@ class MemoryProfiler {
    */
   getRecommendations(memoryGrowth) {
     const recommendations = [];
-    
+
     // Check for large memory growth
-    const largeGrowths = memoryGrowth.filter(g => {
+    const largeGrowths = memoryGrowth.filter((g) => {
       const bytes = this.parseBytes(g.heapGrowth);
       return bytes > 50 * 1024 * 1024; // 50MB
     });
-    
+
     if (largeGrowths.length > 0) {
       recommendations.push({
         type: 'warning',
         message: `Large memory growth detected in ${largeGrowths.length} operations`,
-        details: largeGrowths.map(g => `${g.from} → ${g.to}: ${g.heapGrowth}`)
+        details: largeGrowths.map((g) => `${g.from} → ${g.to}: ${g.heapGrowth}`),
       });
     }
-    
+
     // Check peak memory
-    if (this.peakMemory > 500 * 1024 * 1024) { // 500MB
+    if (this.peakMemory > 500 * 1024 * 1024) {
+      // 500MB
       recommendations.push({
         type: 'warning',
         message: `High peak memory usage: ${this.formatBytes(this.peakMemory)}`,
-        suggestion: 'Consider processing files in smaller batches'
+        suggestion: 'Consider processing files in smaller batches',
       });
     }
-    
+
     // Check for potential memory leaks
     const continuousGrowth = this.checkContinuousGrowth();
     if (continuousGrowth) {
       recommendations.push({
         type: 'error',
         message: 'Potential memory leak detected',
-        details: 'Memory usage continuously increases without significant decreases'
+        details: 'Memory usage continuously increases without significant decreases',
       });
     }
-    
+
     return recommendations;
   }
 
@@ -167,14 +168,14 @@ class MemoryProfiler {
    */
   checkContinuousGrowth() {
     if (this.checkpoints.length < 5) return false;
-    
+
     let increasingCount = 0;
-    for (let i = 1; i < this.checkpoints.length; i++) {
-      if (this.checkpoints[i].raw.heapUsed > this.checkpoints[i - 1].raw.heapUsed) {
+    for (let index = 1; index < this.checkpoints.length; index++) {
+      if (this.checkpoints[index].raw.heapUsed > this.checkpoints[index - 1].raw.heapUsed) {
         increasingCount++;
       }
     }
-    
+
     // If memory increases in more than 80% of checkpoints, might be a leak
     return increasingCount / (this.checkpoints.length - 1) > 0.8;
   }
@@ -184,31 +185,31 @@ class MemoryProfiler {
    */
   formatBytes(bytes) {
     if (bytes === 0) return '0 B';
-    
+
     const k = 1024;
     const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    const index = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return Number.parseFloat((bytes / Math.pow(k, index)).toFixed(2)) + ' ' + sizes[index];
   }
 
   /**
    * Parse human-readable bytes back to number
    */
-  parseBytes(str) {
-    const match = str.match(/^([\d.]+)\s*([KMGT]?B?)$/i);
+  parseBytes(string_) {
+    const match = string_.match(/^([\d.]+)\s*([KMGT]?B?)$/i);
     if (!match) return 0;
-    
-    const value = parseFloat(match[1]);
+
+    const value = Number.parseFloat(match[1]);
     const unit = match[2].toUpperCase();
-    
+
     const multipliers = {
-      'B': 1,
-      'KB': 1024,
-      'MB': 1024 * 1024,
-      'GB': 1024 * 1024 * 1024
+      B: 1,
+      KB: 1024,
+      MB: 1024 * 1024,
+      GB: 1024 * 1024 * 1024,
     };
-    
+
     return value * (multipliers[unit] || 1);
   }
 
@@ -221,4 +222,4 @@ class MemoryProfiler {
 }
 
 // Export singleton instance
-module.exports = new MemoryProfiler();
+module.exports = new MemoryProfiler();

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

@@ -17,13 +17,13 @@ class ModuleManager {
     const modules = await Promise.all([
       this.getModule('chalk'),
       this.getModule('ora'),
-      this.getModule('inquirer')
+      this.getModule('inquirer'),
     ]);
 
     return {
       chalk: modules[0],
       ora: modules[1],
-      inquirer: modules[2]
+      inquirer: modules[2],
     };
   }
 
@@ -64,18 +64,24 @@ class ModuleManager {
    */
   async _loadModule(moduleName) {
     switch (moduleName) {
-      case 'chalk':
+      case 'chalk': {
         return (await import('chalk')).default;
-      case 'ora':
+      }
+      case 'ora': {
         return (await import('ora')).default;
-      case 'inquirer':
+      }
+      case 'inquirer': {
         return (await import('inquirer')).default;
-      case 'glob':
+      }
+      case 'glob': {
         return (await import('glob')).glob;
-      case 'globSync':
+      }
+      case 'globSync': {
         return (await import('glob')).globSync;
-      default:
+      }
+      default: {
         throw new Error(`Unknown module: ${moduleName}`);
+      }
     }
   }
 
@@ -93,13 +99,11 @@ class ModuleManager {
    * @returns {Promise<Object>} Object with module names as keys
    */
   async getModules(moduleNames) {
-    const modules = await Promise.all(
-      moduleNames.map(name => this.getModule(name))
-    );
+    const modules = await Promise.all(moduleNames.map((name) => this.getModule(name)));
 
-    return moduleNames.reduce((acc, name, index) => {
-      acc[name] = modules[index];
-      return acc;
+    return moduleNames.reduce((accumulator, name, index) => {
+      accumulator[name] = modules[index];
+      return accumulator;
     }, {});
   }
 }
@@ -107,4 +111,4 @@ class ModuleManager {
 // Singleton instance
 const moduleManager = new ModuleManager();
 
-module.exports = moduleManager;
+module.exports = moduleManager;

package/tools/installer/lib/resource-locator.js

@@ -43,18 +43,18 @@ class ResourceLocator {
    */
   async findFiles(pattern, options = {}) {
     const cacheKey = `${pattern}:${JSON.stringify(options)}`;
-    
+
     if (this._globCache.has(cacheKey)) {
       return this._globCache.get(cacheKey);
     }
 
     const { glob } = await moduleManager.getModules(['glob']);
     const files = await glob(pattern, options);
-    
+
     // Cache for 5 minutes
     this._globCache.set(cacheKey, files);
     setTimeout(() => this._globCache.delete(cacheKey), 5 * 60 * 1000);
-    
+
     return files;
   }
 
@@ -65,7 +65,7 @@ class ResourceLocator {
    */
   async getAgentPath(agentId) {
     const cacheKey = `agent:${agentId}`;
-    
+
     if (this._pathCache.has(cacheKey)) {
       return this._pathCache.get(cacheKey);
     }
@@ -96,7 +96,7 @@ class ResourceLocator {
    */
   async getAvailableAgents() {
     const cacheKey = 'all-agents';
-    
+
     if (this._pathCache.has(cacheKey)) {
       return this._pathCache.get(cacheKey);
     }
@@ -107,14 +107,11 @@ class ResourceLocator {
 
     // Get agents from bmad-core
     const coreAgents = await this.findFiles('agents/*.md', {
-      cwd: this.getBmadCorePath()
+      cwd: this.getBmadCorePath(),
     });
 
     for (const agentFile of coreAgents) {
-      const content = await fs.readFile(
-        path.join(this.getBmadCorePath(), agentFile),
-        'utf8'
-      );
+      const content = await fs.readFile(path.join(this.getBmadCorePath(), agentFile), 'utf8');
       const yamlContent = extractYamlFromAgent(content);
       if (yamlContent) {
         try {
@@ -123,9 +120,9 @@ class ResourceLocator {
             id: path.basename(agentFile, '.md'),
             name: metadata.agent_name || path.basename(agentFile, '.md'),
             description: metadata.description || 'No description available',
-            source: 'core'
+            source: 'core',
           });
-        } catch (e) {
+        } catch {
           // Skip invalid agents
         }
       }
@@ -144,7 +141,7 @@ class ResourceLocator {
    */
   async getExpansionPacks() {
     const cacheKey = 'expansion-packs';
-    
+
     if (this._pathCache.has(cacheKey)) {
       return this._pathCache.get(cacheKey);
     }
@@ -154,7 +151,7 @@ class ResourceLocator {
 
     if (await fs.pathExists(expansionPacksPath)) {
       const entries = await fs.readdir(expansionPacksPath, { withFileTypes: true });
-      
+
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const configPath = path.join(expansionPacksPath, entry.name, 'config.yaml');
@@ -167,11 +164,12 @@ class ResourceLocator {
                 name: config.name || entry.name,
                 version: config.version || '1.0.0',
                 description: config.description || 'No description available',
-                shortTitle: config['short-title'] || config.description || 'No description available',
+                shortTitle:
+                  config['short-title'] || config.description || 'No description available',
                 author: config.author || 'Unknown',
-                path: path.join(expansionPacksPath, entry.name)
+                path: path.join(expansionPacksPath, entry.name),
               });
-            } catch (e) {
+            } catch {
               // Skip invalid packs
             }
           }
@@ -193,13 +191,13 @@ class ResourceLocator {
    */
   async getTeamConfig(teamId) {
     const cacheKey = `team:${teamId}`;
-    
+
     if (this._pathCache.has(cacheKey)) {
       return this._pathCache.get(cacheKey);
     }
 
     const teamPath = path.join(this.getBmadCorePath(), 'agent-teams', `${teamId}.yaml`);
-    
+
     if (await fs.pathExists(teamPath)) {
       try {
         const yaml = require('js-yaml');
@@ -207,7 +205,7 @@ class ResourceLocator {
         const config = yaml.load(content);
         this._pathCache.set(cacheKey, config);
         return config;
-      } catch (e) {
+      } catch {
         return null;
       }
     }
@@ -222,7 +220,7 @@ class ResourceLocator {
    */
   async getAgentDependencies(agentId) {
     const cacheKey = `deps:${agentId}`;
-    
+
     if (this._pathCache.has(cacheKey)) {
       return this._pathCache.get(cacheKey);
     }
@@ -244,11 +242,11 @@ class ResourceLocator {
       const yaml = require('js-yaml');
       const metadata = yaml.load(yamlContent);
       const dependencies = metadata.dependencies || {};
-      
+
       // Flatten dependencies
       const allDeps = [];
       const byType = {};
-      
+
       for (const [type, deps] of Object.entries(dependencies)) {
         if (Array.isArray(deps)) {
           byType[type] = deps;
@@ -261,7 +259,7 @@ class ResourceLocator {
       const result = { all: allDeps, byType };
       this._pathCache.set(cacheKey, result);
       return result;
-    } catch (e) {
+    } catch {
       return { all: [], byType: {} };
     }
   }
@@ -281,13 +279,13 @@ class ResourceLocator {
    */
   async getIdeConfig(ideId) {
     const cacheKey = `ide:${ideId}`;
-    
+
     if (this._pathCache.has(cacheKey)) {
       return this._pathCache.get(cacheKey);
     }
 
     const idePath = path.join(this.getBmadCorePath(), 'ide-rules', `${ideId}.yaml`);
-    
+
     if (await fs.pathExists(idePath)) {
       try {
         const yaml = require('js-yaml');
@@ -295,7 +293,7 @@ class ResourceLocator {
         const config = yaml.load(content);
         this._pathCache.set(cacheKey, config);
         return config;
-      } catch (e) {
+      } catch {
         return null;
       }
     }
@@ -307,4 +305,4 @@ class ResourceLocator {
 // Singleton instance
 const resourceLocator = new ResourceLocator();
 
-module.exports = resourceLocator;
+module.exports = resourceLocator;

package/tools/installer/package.json

@@ -1,15 +1,7 @@
 {
   "name": "bmad-method",
-  "version": "4.37.0",
+  "version": "5.1.3",
   "description": "BMad Method installer - AI-powered Agile development framework",
-  "main": "lib/installer.js",
-  "bin": {
-    "bmad": "./bin/bmad.js",
-    "bmad-method": "./bin/bmad.js"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "keywords": [
     "bmad",
     "agile",
@@ -19,8 +11,24 @@
     "installer",
     "agents"
   ],
-  "author": "BMad Team",
+  "homepage": "https://github.com/bmad-team/bmad-method#readme",
+  "bugs": {
+    "url": "https://github.com/bmad-team/bmad-method/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bmad-team/bmad-method.git"
+  },
   "license": "MIT",
+  "author": "BMad Team",
+  "main": "lib/installer.js",
+  "bin": {
+    "bmad": "./bin/bmad.js",
+    "bmad-method": "./bin/bmad.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^14.0.0",
@@ -32,13 +40,5 @@
   },
   "engines": {
     "node": ">=20.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/bmad-team/bmad-method.git"
-  },
-  "bugs": {
-    "url": "https://github.com/bmad-team/bmad-method/issues"
-  },
-  "homepage": "https://github.com/bmad-team/bmad-method#readme"
+  }
 }