bmad-method 4.19.2 → 4.21.0

package/tools/bump-core-version.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const args = process.argv.slice(2);
+const bumpType = args[0] || 'minor'; // default to minor
+
+if (!['major', 'minor', 'patch'].includes(bumpType)) {
+  console.log('Usage: node bump-core-version.js [major|minor|patch]');
+  console.log('Default: minor');
+  process.exit(1);
+}
+
+function bumpVersion(currentVersion, type) {
+  const [major, minor, patch] = currentVersion.split('.').map(Number);
+  
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      return currentVersion;
+  }
+}
+
+async function bumpCoreVersion() {
+  try {
+    const coreConfigPath = path.join(__dirname, '..', 'bmad-core', 'core-config.yml');
+    
+    const coreConfigContent = fs.readFileSync(coreConfigPath, 'utf8');
+    const coreConfig = yaml.load(coreConfigContent);
+    const oldVersion = coreConfig.version || '1.0.0';
+    const newVersion = bumpVersion(oldVersion, bumpType);
+    
+    coreConfig.version = newVersion;
+    
+    const updatedYaml = yaml.dump(coreConfig, { indent: 2 });
+    fs.writeFileSync(coreConfigPath, updatedYaml);
+    
+    console.log(`✓ BMad Core: ${oldVersion} → ${newVersion}`);
+    console.log(`\n✓ Successfully bumped BMad Core with ${bumpType} version bump`);
+    console.log('\nNext steps:');
+    console.log('1. Test the changes');
+    console.log('2. Commit: git add -A && git commit -m "chore: bump core version (' + bumpType + ')"');
+    
+  } catch (error) {
+    console.error('Error updating core version:', error.message);
+    process.exit(1);
+  }
+}
+
+bumpCoreVersion();

package/tools/bump-expansion-version.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const args = process.argv.slice(2);
+
+if (args.length < 1 || args.length > 2) {
+  console.log('Usage: node bump-expansion-version.js <expansion-pack-id> [major|minor|patch]');
+  console.log('Default: minor');
+  console.log('Example: node bump-expansion-version.js bmad-creator-tools patch');
+  process.exit(1);
+}
+
+const packId = args[0];
+const bumpType = args[1] || 'minor'; // default to minor
+
+if (!['major', 'minor', 'patch'].includes(bumpType)) {
+  console.error('Error: Bump type must be major, minor, or patch');
+  process.exit(1);
+}
+
+function bumpVersion(currentVersion, type) {
+  const [major, minor, patch] = currentVersion.split('.').map(Number);
+  
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      return currentVersion;
+  }
+}
+
+async function updateVersion() {
+  try {
+    const configPath = path.join(__dirname, '..', 'expansion-packs', packId, 'config.yml');
+    
+    if (!fs.existsSync(configPath)) {
+      console.error(`Error: Expansion pack '${packId}' not found`);
+      console.log('\nAvailable expansion packs:');
+      const expansionPacksDir = path.join(__dirname, '..', 'expansion-packs');
+      const entries = fs.readdirSync(expansionPacksDir, { withFileTypes: true });
+      entries.forEach(entry => {
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          console.log(`  - ${entry.name}`);
+        }
+      });
+      process.exit(1);
+    }
+    
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.load(configContent);
+    const oldVersion = config.version || '1.0.0';
+    const newVersion = bumpVersion(oldVersion, bumpType);
+    
+    config.version = newVersion;
+    
+    const updatedYaml = yaml.dump(config, { indent: 2 });
+    fs.writeFileSync(configPath, updatedYaml);
+    
+    console.log(`✓ ${packId}: ${oldVersion} → ${newVersion}`);
+    console.log(`\n✓ Successfully bumped ${packId} with ${bumpType} version bump`);
+    console.log('\nNext steps:');
+    console.log('1. Test the changes');
+    console.log('2. Commit: git add -A && git commit -m "chore: bump ' + packId + ' version (' + bumpType + ')"');
+    
+  } catch (error) {
+    console.error('Error updating version:', error.message);
+    process.exit(1);
+  }
+}
+
+updateVersion();

package/tools/installer/bin/bmad.js

@@ -2,6 +2,8 @@
 
 const { program } = require('commander');
 const path = require('path');
+const fs = require('fs').promises;
+const yaml = require('js-yaml');
 
 // Dynamic imports for ES modules
 let chalk, inquirer;
@@ -40,22 +42,20 @@ try {
 
 program
   .version(version)
-  .description('BMAD Method installer - AI-powered Agile development framework');
+  .description('BMAD Method installer - Universal AI agent framework for any domain');
 
 program
   .command('install')
   .description('Install BMAD Method agents and tools')
-  .option('-f, --full', 'Install complete .bmad-core folder')
-  .option('-a, --agent <agent>', 'Install specific agent with dependencies')
-  .option('-t, --team <team>', 'Install specific team with required agents and dependencies')
+  .option('-f, --full', 'Install complete BMAD Method')
   .option('-x, --expansion-only', 'Install only expansion packs (no bmad-core)')
-  .option('-d, --directory <path>', 'Installation directory (default: .bmad-core)')
+  .option('-d, --directory <path>', 'Installation directory')
   .option('-i, --ide <ide...>', 'Configure for specific IDE(s) - can specify multiple (cursor, claude-code, windsurf, roo, cline, gemini, other)')
   .option('-e, --expansion-packs <packs...>', 'Install specific expansion packs (can specify multiple)')
   .action(async (options) => {
     try {
       await initializeModules();
-      if (!options.full && !options.agent && !options.team && !options.expansionOnly) {
+      if (!options.full && !options.expansionOnly) {
         // Interactive mode
         const answers = await promptInstallation();
         if (!answers._alreadyInstalled) {
@@ -64,15 +64,11 @@ program
       } else {
         // Direct mode
         let installType = 'full';
-        if (options.agent) installType = 'single-agent';
-        else if (options.team) installType = 'team';
-        else if (options.expansionOnly) installType = 'expansion-only';
+        if (options.expansionOnly) installType = 'expansion-only';
 
         const config = {
           installType,
-          agent: options.agent,
-          team: options.team,
-          directory: options.directory || '.bmad-core',
+          directory: options.directory || '.',
           ides: (options.ide || []).filter(ide => ide !== 'other'),
           expansionPacks: options.expansionPacks || []
         };
@@ -100,19 +96,6 @@ program
     }
   });
 
-program
-  .command('list')
-  .description('List available agents')
-  .action(async () => {
-    try {
-      await installer.listAgents();
-    } catch (error) {
-      if (!chalk) await initializeModules();
-      console.error(chalk.red('Error:'), error.message);
-      process.exit(1);
-    }
-  });
-
 program
   .command('list:expansions')
   .description('List available expansion packs')
@@ -145,7 +128,7 @@ async function promptInstallation() {
 
   const answers = {};
 
-  // Ask for installation directory
+  // Ask for installation directory first
   const { directory } = await inquirer.prompt([
     {
       type: 'input',
@@ -161,147 +144,85 @@ async function promptInstallation() {
   ]);
   answers.directory = directory;
 
-  // Check if this is an existing v4 installation
-  const installDir = path.resolve(answers.directory);
+  // Detect existing installations
+  const installDir = path.resolve(directory);
   const state = await installer.detectInstallationState(installDir);
-
+  
+  // Check for existing expansion packs
+  const existingExpansionPacks = state.expansionPacks || {};
+  
+  // Get available expansion packs
+  const availableExpansionPacks = await installer.getAvailableExpansionPacks();
+  
+  // Build choices list
+  const choices = [];
+  
+  // Load core config to get short-title
+  const coreConfigPath = path.join(__dirname, '..', '..', '..', 'bmad-core', 'core-config.yml');
+  const coreConfig = yaml.load(await fs.readFile(coreConfigPath, 'utf8'));
+  const coreShortTitle = coreConfig['short-title'] || 'BMad Agile Core System';
+  
+  // Add BMAD core option
+  let bmadOptionText;
   if (state.type === 'v4_existing') {
-    console.log(chalk.yellow('\n🔍 Found existing BMAD v4 installation'));
-    console.log(`   Directory: ${installDir}`);
-    console.log(`   Version: ${state.manifest?.version || 'Unknown'}`);
-    console.log(`   Installed: ${state.manifest?.installed_at ? new Date(state.manifest.installed_at).toLocaleDateString() : 'Unknown'}`);
-
-    const { shouldUpdate } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldUpdate',
-        message: 'Would you like to update your existing BMAD v4 installation?',
-        default: true
-      }
-    ]);
-
-    if (shouldUpdate) {
-      // Skip other prompts and go directly to update
-      answers.installType = 'update';
-      answers._alreadyInstalled = true; // Flag to prevent double installation
-      await installer.install(answers);
-      return answers; // Return the answers object
-    }
-    // If user doesn't want to update, continue with normal flow
+    const currentVersion = state.manifest?.version || 'unknown';
+    const newVersion = coreConfig.version || 'unknown'; // Use version from core-config.yml
+    const versionInfo = currentVersion === newVersion 
+      ? `(v${currentVersion} - reinstall)`
+      : `(v${currentVersion} → v${newVersion})`;
+    bmadOptionText = `Update ${coreShortTitle} ${versionInfo} .bmad-core`;
+  } else {
+    bmadOptionText = `Install ${coreShortTitle} (v${coreConfig.version || version}) .bmad-core`;
   }
-
-  // Ask for installation type
-  const { installType } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'installType',
-      message: 'How would you like to install BMAD?',
-      choices: [
-        {
-          name: 'Complete installation (recommended) - All agents and tools',
-          value: 'full'
-        },
-        {
-          name: 'Team installation - Install a specific team with required agents',
-          value: 'team'
-        },
-        {
-          name: 'Single agent - Choose one agent to install',
-          value: 'single-agent'
-        },
-        {
-          name: 'Expansion packs only - Install expansion packs without bmad-core',
-          value: 'expansion-only'
-        }
-      ]
+  
+  choices.push({
+    name: bmadOptionText,
+    value: 'bmad-core',
+    checked: true
+  });
+  
+  // Add expansion pack options
+  for (const pack of availableExpansionPacks) {
+    const existing = existingExpansionPacks[pack.id];
+    let packOptionText;
+    
+    if (existing) {
+      const currentVersion = existing.manifest?.version || 'unknown';
+      const newVersion = pack.version;
+      const versionInfo = currentVersion === newVersion 
+        ? `(v${currentVersion} - reinstall)`
+        : `(v${currentVersion} → v${newVersion})`;
+      packOptionText = `Update ${pack.description} ${versionInfo} .${pack.id}`;
+    } else {
+      packOptionText = `Install ${pack.description} (v${pack.version}) .${pack.id}`;
     }
-  ]);
-  answers.installType = installType;
-
-  // If single agent, ask which one
-  if (installType === 'single-agent') {
-    const agents = await installer.getAvailableAgents();
-    const { agent } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'agent',
-        message: 'Select an agent to install:',
-        choices: agents.map(a => ({
-          name: `${a.id} - ${a.name} (${a.description})`,
-          value: a.id
-        }))
-      }
-    ]);
-    answers.agent = agent;
-  }
-
-  // If team installation, ask which team
-  if (installType === 'team') {
-    const teams = await installer.getAvailableTeams();
-    const { team } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'team',
-        message: 'Select a team to install in your IDE project folder:',
-        choices: teams.map(t => ({
-          name: `${t.icon || '📋'} ${t.name}: ${t.description}`,
-          value: t.id
-        }))
-      }
-    ]);
-    answers.team = team;
+    
+    choices.push({
+      name: packOptionText,
+      value: pack.id,
+      checked: false
+    });
   }
-
-  // Ask for expansion pack selection
-  if (installType === 'full' || installType === 'team' || installType === 'expansion-only') {
-    try {
-      const availableExpansionPacks = await installer.getAvailableExpansionPacks();
-
-      if (availableExpansionPacks.length > 0) {
-        let choices;
-        let message;
-
-        if (installType === 'expansion-only') {
-          message = 'Select expansion packs to install (required):'
-          choices = availableExpansionPacks.map(pack => ({
-            name: `${pack.name} - ${pack.description}`,
-            value: pack.id
-          }));
-        } else {
-          message = 'Select expansion packs to install (press Enter to skip, or check any to install):';
-          choices = availableExpansionPacks.map(pack => ({
-            name: `${pack.name} - ${pack.description}`,
-            value: pack.id
-          }));
+  
+  // Ask what to install
+  const { selectedItems } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedItems',
+      message: 'Select what to install/update (use space to select, enter to continue):',
+      choices: choices,
+      validate: (selected) => {
+        if (selected.length === 0) {
+          return 'Please select at least one item to install';
         }
-
-        const { expansionPacks } = await inquirer.prompt([
-          {
-            type: 'checkbox',
-            name: 'expansionPacks',
-            message,
-            choices,
-            validate: installType === 'expansion-only' ? (answer) => {
-              if (answer.length < 1) {
-                return 'You must select at least one expansion pack for expansion-only installation.';
-              }
-              return true;
-            } : undefined
-          }
-        ]);
-
-        // Use selected expansion packs directly
-        answers.expansionPacks = expansionPacks;
-      } else {
-        answers.expansionPacks = [];
+        return true;
       }
-    } catch (error) {
-      console.warn(chalk.yellow('Warning: Could not load expansion packs. Continuing without them.'));
-      answers.expansionPacks = [];
     }
-  } else {
-    answers.expansionPacks = [];
-  }
+  ]);
+  
+  // Process selections
+  answers.installType = selectedItems.includes('bmad-core') ? 'full' : 'expansion-only';
+  answers.expansionPacks = selectedItems.filter(item => item !== 'bmad-core');
 
   // Ask for IDE configuration
   const { ides } = await inquirer.prompt([
@@ -329,7 +250,7 @@ async function promptInstallation() {
       type: 'confirm',
       name: 'includeWebBundles',
       message: 'Would you like to include pre-built web bundles? (standalone files for ChatGPT, Claude, Gemini)',
-      default: true
+      default: false
     }
   ]);
 

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

@@ -83,12 +83,22 @@ class FileManager {
       this.manifestFile
     );
 
+    // Read version from core-config.yml
+    const coreConfigPath = path.join(__dirname, "../../../bmad-core/core-config.yml");
+    let coreVersion = "unknown";
+    try {
+      const coreConfigContent = await fs.readFile(coreConfigPath, "utf8");
+      const coreConfig = yaml.load(coreConfigContent);
+      coreVersion = coreConfig.version || "unknown";
+    } catch (error) {
+      console.warn("Could not read version from core-config.yml, 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: [],
@@ -128,6 +138,21 @@ class FileManager {
     }
   }
 
+  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 (error) {
+      return null;
+    }
+  }
+
   async checkModifiedFiles(installDir, manifest) {
     const modified = [];
 
@@ -143,6 +168,33 @@ 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.yml')) {
+        continue;
+      }
+      
+      if (!(await this.pathExists(filePath))) {
+        result.missing.push(file.path);
+      } else {
+        const currentHash = await this.calculateFileHash(filePath);
+        if (currentHash && currentHash !== file.hash) {
+          result.modified.push(file.path);
+        }
+      }
+    }
+
+    return result;
+  }
+
   async backupFile(filePath) {
     const backupPath = filePath + ".bak";
     let counter = 1;
@@ -183,6 +235,42 @@ 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;
+  }
 }
 
 module.exports = new FileManager();