bmad-method 4.2.0 → 4.4.1

package/tools/installer/lib/installer.js

@@ -1,18 +1,94 @@
-const path = require("path");
-const chalk = require("chalk");
-const ora = require("ora");
-const inquirer = require("inquirer");
+const path = require("node:path");
 const fileManager = require("./file-manager");
 const configLoader = require("./config-loader");
 const ideSetup = require("./ide-setup");
 
+// Dynamic imports for ES modules
+let chalk, ora, inquirer;
+
+// Initialize ES modules
+async function initializeModules() {
+  if (!chalk) {
+    chalk = (await import("chalk")).default;
+    ora = (await import("ora")).default;
+    inquirer = (await import("inquirer")).default;
+  }
+}
+
 class Installer {
   async install(config) {
+    // Initialize ES modules
+    await initializeModules();
+    
     const spinner = ora("Analyzing installation directory...").start();
 
     try {
       // Resolve installation directory
-      const installDir = path.resolve(config.directory);
+      let installDir = path.resolve(config.directory);
+      if (path.basename(installDir) === '.bmad-core') {
+        // If user points directly to .bmad-core, treat its parent as the project root
+        installDir = path.dirname(installDir);
+      }
+
+      // Check if directory exists and handle non-existent directories
+      if (!(await fileManager.pathExists(installDir))) {
+        spinner.stop();
+        console.log(chalk.yellow(`\nThe directory ${chalk.bold(installDir)} does not exist.`));
+        
+        const { action } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: [
+              {
+                name: 'Create the directory and continue',
+                value: 'create'
+              },
+              {
+                name: 'Choose a different directory',
+                value: 'change'
+              },
+              {
+                name: 'Cancel installation',
+                value: 'cancel'
+              }
+            ]
+          }
+        ]);
+
+        if (action === 'cancel') {
+          console.log(chalk.red('Installation cancelled.'));
+          process.exit(0);
+        } else if (action === 'change') {
+          const { newDirectory } = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'newDirectory',
+              message: 'Enter the new directory path:',
+              validate: (input) => {
+                if (!input.trim()) {
+                  return 'Please enter a valid directory path';
+                }
+                return true;
+              }
+            }
+          ]);
+          config.directory = newDirectory;
+          return await this.install(config); // Recursive call with new directory
+        } else if (action === 'create') {
+          try {
+            await fileManager.ensureDirectory(installDir);
+            console.log(chalk.green(`✓ Created directory: ${installDir}`));
+          } catch (error) {
+            console.error(chalk.red(`Failed to create directory: ${error.message}`));
+            console.error(chalk.yellow('You may need to check permissions or use a different path.'));
+            process.exit(1);
+          }
+        }
+        
+        spinner.start("Analyzing installation directory...");
+      }
 
       // Detect current state
       const state = await this.detectInstallationState(installDir);
@@ -53,6 +129,8 @@ class Installer {
   }
 
   async detectInstallationState(installDir) {
+    // Ensure modules are initialized
+    await initializeModules();
     const state = {
       type: "clean",
       hasV4Manifest: false,
@@ -75,7 +153,7 @@ class Installer {
       state.type = "v4_existing";
       state.hasV4Manifest = true;
       state.hasBmadCore = true;
-      state.manifest = await fileManager.readManifest(bmadCorePath);
+      state.manifest = await fileManager.readManifest(installDir);
       return state;
     }
 
@@ -103,15 +181,17 @@ class Installer {
     });
 
     if (files.length > 0) {
-      state.type = "unknown_existing";
+      // Directory has other files, but no BMAD installation.
+      // Treat as clean install but record that it isn't empty.
       state.hasOtherFiles = true;
-      return state;
     }
 
     return state; // clean install
   }
 
   async performFreshInstall(config, installDir, spinner) {
+    // Ensure modules are initialized
+    await initializeModules();
     spinner.text = "Installing BMAD Method...";
 
     let files = [];
@@ -181,10 +261,17 @@ class Installer {
       }
     }
 
+    // Install expansion packs if requested
+    const expansionFiles = await this.installExpansionPacks(installDir, config.expansionPacks, spinner);
+    files.push(...expansionFiles);
+
     // Set up IDE integration if requested
-    if (config.ide) {
-      spinner.text = `Setting up ${config.ide} integration...`;
-      await ideSetup.setup(config.ide, installDir, config.agent);
+    const ides = config.ides || (config.ide ? [config.ide] : []);
+    if (ides.length > 0) {
+      for (const ide of ides) {
+        spinner.text = `Setting up ${ide} integration...`;
+        await ideSetup.setup(ide, installDir, config.agent);
+      }
     }
 
     // Create manifest
@@ -196,6 +283,8 @@ class Installer {
   }
 
   async handleExistingV4Installation(config, installDir, state, spinner) {
+    // Ensure modules are initialized
+    await initializeModules();
     spinner.stop();
 
     console.log(chalk.yellow("\n🔍 Found existing BMAD v4 installation"));
@@ -222,7 +311,7 @@ class Installer {
 
     switch (action) {
       case "update":
-        return await this.performUpdate(installDir, state.manifest, spinner);
+        return await this.performUpdate(config, installDir, state.manifest, spinner);
       case "reinstall":
         return await this.performReinstall(config, installDir, spinner);
       case "cancel":
@@ -232,6 +321,8 @@ class Installer {
   }
 
   async handleV3Installation(config, installDir, state, spinner) {
+    // Ensure modules are initialized
+    await initializeModules();
     spinner.stop();
 
     console.log(
@@ -253,11 +344,12 @@ class Installer {
     ]);
 
     switch (action) {
-      case "upgrade":
+      case "upgrade": {
         console.log(chalk.cyan("\n📦 Starting v3 to v4 upgrade process..."));
         const V3ToV4Upgrader = require("../../upgraders/v3-to-v4-upgrader");
         const upgrader = new V3ToV4Upgrader();
         return await upgrader.upgrade({ projectPath: installDir });
+      }
       case "alongside":
         return await this.performFreshInstall(config, installDir, spinner);
       case "cancel":
@@ -267,6 +359,8 @@ class Installer {
   }
 
   async handleUnknownInstallation(config, installDir, state, spinner) {
+    // Ensure modules are initialized
+    await initializeModules();
     spinner.stop();
 
     console.log(chalk.yellow("\n⚠️  Directory contains existing files"));
@@ -295,7 +389,7 @@ class Installer {
     switch (action) {
       case "force":
         return await this.performFreshInstall(config, installDir, spinner);
-      case "different":
+      case "different": {
         const { newDir } = await inquirer.prompt([
           {
             type: "input",
@@ -306,13 +400,14 @@ class Installer {
         ]);
         config.directory = newDir;
         return await this.install(config);
+      }
       case "cancel":
         console.log("Installation cancelled.");
         return;
     }
   }
 
-  async performUpdate(installDir, manifest, spinner) {
+  async performUpdate(newConfig, installDir, manifest, spinner) {
     spinner.start("Checking for updates...");
 
     try {
@@ -326,7 +421,9 @@ class Installer {
       if (modifiedFiles.length > 0) {
         spinner.warn("Found modified files");
         console.log(chalk.yellow("\nThe following files have been modified:"));
-        modifiedFiles.forEach((file) => console.log(`  - ${file}`));
+        for (const file of modifiedFiles) {
+          console.log(`  - ${file}`);
+        }
 
         const { action } = await inquirer.prompt([
           {
@@ -364,7 +461,7 @@ class Installer {
         installType: manifest.install_type,
         agent: manifest.agent,
         directory: installDir,
-        ide: manifest.ide_setup,
+        ide: newConfig.ide || manifest.ide_setup, // Use new IDE choice if provided
       };
 
       await this.performFreshInstall(config, installDir, spinner);
@@ -389,13 +486,16 @@ class Installer {
   showSuccessMessage(config, installDir) {
     console.log(chalk.green("\n✓ BMAD Method installed successfully!\n"));
 
-    if (config.ide) {
-      const ideConfig = configLoader.getIdeConfiguration(config.ide);
-      if (ideConfig && ideConfig.instructions) {
-        console.log(
-          chalk.bold("To use BMAD agents in " + ideConfig.name + ":")
-        );
-        console.log(ideConfig.instructions);
+    const ides = config.ides || (config.ide ? [config.ide] : []);
+    if (ides.length > 0) {
+      for (const ide of ides) {
+        const ideConfig = configLoader.getIdeConfiguration(ide);
+        if (ideConfig?.instructions) {
+          console.log(
+            chalk.bold(`To use BMAD agents in ${ideConfig.name}:`)
+          );
+          console.log(ideConfig.instructions);
+        }
       }
     } else {
       console.log(chalk.yellow("No IDE configuration was set up."));
@@ -405,6 +505,30 @@ class Installer {
       );
     }
 
+    // Information about installation components
+    console.log(chalk.bold("\n🎯 Installation Summary:"));
+    console.log(chalk.green("✓ .bmad-core framework installed with all agents and workflows"));
+    
+    if (config.expansionPacks && config.expansionPacks.length > 0) {
+      const packNames = config.expansionPacks.join(", ");
+      console.log(chalk.green(`✓ Expansion packs installed: ${packNames}`));
+    }
+    
+    if (ides.length > 0) {
+      const ideNames = ides.map(ide => {
+        const ideConfig = configLoader.getIdeConfiguration(ide);
+        return ideConfig?.name || ide;
+      }).join(", ");
+      console.log(chalk.green(`✓ IDE rules and configurations set up for: ${ideNames}`));
+    }
+
+    // Information about web bundles
+    console.log(chalk.bold("\n📦 Web Bundles Available:"));
+    console.log("Self-contained web bundles have been included in your installation:");
+    console.log(chalk.cyan(`  ${installDir}/.bmad-core/web-bundles/`));
+    console.log("These bundles work independently without this installation and can be");
+    console.log("shared, moved, or used in other projects as standalone files.");
+
     if (config.installType === "single-agent") {
       console.log(
         chalk.dim(
@@ -418,7 +542,9 @@ class Installer {
   }
 
   // Legacy method for backward compatibility
-  async update(options) {
+  async update() {
+    // Initialize ES modules
+    await initializeModules();
     console.log(chalk.yellow('The "update" command is deprecated.'));
     console.log(
       'Please use "install" instead - it will detect and offer to update existing installations.'
@@ -432,26 +558,56 @@ class Installer {
         ide: null,
       };
       return await this.install(config);
-    } else {
-      console.log(chalk.red("No BMAD installation found."));
     }
+    console.log(chalk.red("No BMAD installation found."));
   }
 
   async listAgents() {
+    // Initialize ES modules
+    await initializeModules();
     const agents = await configLoader.getAvailableAgents();
 
     console.log(chalk.bold("\nAvailable BMAD Agents:\n"));
 
-    agents.forEach((agent) => {
+    for (const agent of agents) {
       console.log(chalk.cyan(`  ${agent.id.padEnd(20)}`), agent.description);
-    });
+    }
 
     console.log(
       chalk.dim("\nInstall with: npx bmad-method install --agent=<id>\n")
     );
   }
 
+  async listExpansionPacks() {
+    // Initialize ES modules
+    await initializeModules();
+    const expansionPacks = await this.getAvailableExpansionPacks();
+
+    console.log(chalk.bold("\nAvailable BMAD Expansion Packs:\n"));
+
+    if (expansionPacks.length === 0) {
+      console.log(chalk.yellow("No expansion packs found."));
+      return;
+    }
+
+    for (const pack of expansionPacks) {
+      console.log(chalk.cyan(`  ${pack.id.padEnd(20)}`), 
+                  `${pack.name} v${pack.version}`);
+      console.log(chalk.dim(`  ${' '.repeat(22)}${pack.description}`));
+      if (pack.author && pack.author !== 'Unknown') {
+        console.log(chalk.dim(`  ${' '.repeat(22)}by ${pack.author}`));
+      }
+      console.log();
+    }
+
+    console.log(
+      chalk.dim("Install with: npx bmad-method install --full --expansion-packs <id>\n")
+    );
+  }
+
   async showStatus() {
+    // Initialize ES modules
+    await initializeModules();
     const installDir = await this.findInstallation();
 
     if (!installDir) {
@@ -504,6 +660,96 @@ class Installer {
     return configLoader.getAvailableAgents();
   }
 
+  async getAvailableExpansionPacks() {
+    return configLoader.getAvailableExpansionPacks();
+  }
+
+  async installExpansionPacks(installDir, selectedPacks, spinner) {
+    if (!selectedPacks || selectedPacks.length === 0) {
+      return [];
+    }
+
+    const installedFiles = [];
+    const glob = require('glob');
+
+    for (const packId of selectedPacks) {
+      spinner.text = `Installing expansion pack: ${packId}...`;
+      
+      try {
+        const expansionPacks = await this.getAvailableExpansionPacks();
+        const pack = expansionPacks.find(p => p.id === packId);
+        
+        if (!pack) {
+          console.warn(`Expansion pack ${packId} not found, skipping...`);
+          continue;
+        }
+
+        const expansionPackDir = path.dirname(pack.manifestPath);
+        
+        // Define the folders to copy from expansion packs to .bmad-core
+        const foldersToSync = [
+          'agents',
+          'agent-teams',
+          'templates',
+          'tasks',
+          'checklists',
+          'workflows',
+          'data',
+          'utils',
+          'schemas'
+        ];
+
+        // Copy each folder if it exists
+        for (const folder of foldersToSync) {
+          const sourceFolder = path.join(expansionPackDir, folder);
+          
+          // Check if folder exists in expansion pack
+          if (await fileManager.pathExists(sourceFolder)) {
+            // Get all files in this folder
+            const files = glob.sync('**/*', {
+              cwd: sourceFolder,
+              nodir: true
+            });
+
+            // Copy each file to the destination
+            for (const file of files) {
+              const sourcePath = path.join(sourceFolder, file);
+              const destPath = path.join(installDir, '.bmad-core', folder, file);
+              
+              if (await fileManager.copyFile(sourcePath, destPath)) {
+                installedFiles.push(path.join('.bmad-core', folder, file));
+              }
+            }
+          }
+        }
+
+        // Also copy web-bundles if they exist (to a different location)
+        const webBundlesSource = path.join(expansionPackDir, 'web-bundles');
+        if (await fileManager.pathExists(webBundlesSource)) {
+          const files = glob.sync('**/*', {
+            cwd: webBundlesSource,
+            nodir: true
+          });
+
+          for (const file of files) {
+            const sourcePath = path.join(webBundlesSource, file);
+            const destPath = path.join(installDir, '.bmad-core', 'web-bundles', 'expansion-packs', packId, file);
+            
+            if (await fileManager.copyFile(sourcePath, destPath)) {
+              installedFiles.push(path.join('.bmad-core', 'web-bundles', 'expansion-packs', packId, file));
+            }
+          }
+        }
+
+        console.log(chalk.green(`✓ Installed expansion pack: ${pack.name}`));
+      } catch (error) {
+        console.error(chalk.red(`Failed to install expansion pack ${packId}: ${error.message}`));
+      }
+    }
+
+    return installedFiles;
+  }
+
   async findInstallation() {
     // Look for .bmad-core in current directory or parent directories
     let currentDir = process.cwd();