bmad-method 5.1.2 → 6.0.0-alpha.0

package/tools/cli/bundlers/bundle-web.js

@@ -0,0 +1,157 @@
+const { WebBundler } = require('./web-bundler');
+const chalk = require('chalk');
+const { program } = require('commander');
+const path = require('node:path');
+const fs = require('fs-extra');
+
+program.name('bundle-web').description('Generate web bundles for BMAD agents and teams').version('1.0.0');
+
+program
+  .command('all')
+  .description('Bundle all modules')
+  .option('-o, --output <path>', 'Output directory', 'web-bundles')
+  .action(async (options) => {
+    try {
+      const bundler = new WebBundler(null, options.output);
+      await bundler.bundleAll();
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('rebundle')
+  .description('Clean and rebundle all modules')
+  .option('-o, --output <path>', 'Output directory', 'web-bundles')
+  .action(async (options) => {
+    try {
+      // Clean output directory first
+      const outputDir = path.isAbsolute(options.output) ? options.output : path.join(process.cwd(), options.output);
+
+      if (await fs.pathExists(outputDir)) {
+        console.log(chalk.cyan(`🧹 Cleaning ${options.output}...`));
+        await fs.emptyDir(outputDir);
+      }
+
+      // Bundle all
+      const bundler = new WebBundler(null, options.output);
+      await bundler.bundleAll();
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('module <name>')
+  .description('Bundle a specific module')
+  .option('-o, --output <path>', 'Output directory', 'web-bundles')
+  .action(async (moduleName, options) => {
+    try {
+      const bundler = new WebBundler(null, options.output);
+      await bundler.loadWebActivation();
+      const result = await bundler.bundleModule(moduleName);
+
+      if (result.agents.length === 0 && result.teams.length === 0) {
+        console.log(chalk.yellow(`No agents or teams found in module: ${moduleName}`));
+      } else {
+        console.log(chalk.green(`\n✨ Successfully bundled ${result.agents.length} agents and ${result.teams.length} teams`));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('agent <module> <agent>')
+  .description('Bundle a specific agent')
+  .option('-o, --output <path>', 'Output directory', 'web-bundles')
+  .action(async (moduleName, agentFile, options) => {
+    try {
+      const bundler = new WebBundler(null, options.output);
+      await bundler.loadWebActivation();
+
+      // Ensure .md extension
+      if (!agentFile.endsWith('.md')) {
+        agentFile += '.md';
+      }
+
+      // Pre-discover module for complete manifests
+      await bundler.preDiscoverModule(moduleName);
+
+      await bundler.bundleAgent(moduleName, agentFile, false);
+      console.log(chalk.green(`\n✨ Successfully bundled agent: ${agentFile}`));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list')
+  .description('List available modules and agents')
+  .action(async () => {
+    try {
+      const bundler = new WebBundler();
+      const modules = await bundler.discoverModules();
+
+      console.log(chalk.cyan.bold('\n📦 Available Modules:\n'));
+
+      for (const module of modules) {
+        console.log(chalk.bold(`  ${module}/`));
+
+        const modulePath = path.join(bundler.modulesPath, module);
+        const agents = await bundler.discoverAgents(modulePath);
+        const teams = await bundler.discoverTeams(modulePath);
+
+        if (agents.length > 0) {
+          console.log(chalk.gray('    agents/'));
+          for (const agent of agents) {
+            console.log(chalk.gray(`      - ${agent}`));
+          }
+        }
+
+        if (teams.length > 0) {
+          console.log(chalk.gray('    teams/'));
+          for (const team of teams) {
+            console.log(chalk.gray(`      - ${team}`));
+          }
+        }
+      }
+
+      console.log('');
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('clean')
+  .description('Remove all web bundles')
+  .action(async () => {
+    try {
+      const fs = require('fs-extra');
+      const outputDir = path.join(process.cwd(), 'web-bundles');
+
+      if (await fs.pathExists(outputDir)) {
+        await fs.remove(outputDir);
+        console.log(chalk.green('✓ Web bundles directory cleaned'));
+      } else {
+        console.log(chalk.yellow('Web bundles directory does not exist'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Parse command line arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (process.argv.slice(2).length === 0) {
+  program.outputHelp();
+}

package/tools/cli/bundlers/test-analyst.js

@@ -0,0 +1,28 @@
+const { WebBundler } = require('./web-bundler');
+const chalk = require('chalk');
+const path = require('node:path');
+
+async function testAnalystBundle() {
+  console.log(chalk.cyan.bold('\n🧪 Testing Analyst Agent Bundle\n'));
+
+  try {
+    const bundler = new WebBundler();
+
+    // Load web activation first
+    await bundler.loadWebActivation();
+
+    // Bundle just the analyst agent from bmm module
+    // Only bundle the analyst for testing
+    const agentPath = path.join(bundler.modulesPath, 'bmm', 'agents', 'analyst.md');
+    await bundler.bundleAgent('bmm', 'analyst.md');
+
+    console.log(chalk.green.bold('\n✅ Test completed successfully!\n'));
+  } catch (error) {
+    console.error(chalk.red('\n❌ Test failed:'), error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+// Run test
+testAnalystBundle();

package/tools/cli/bundlers/test-bundler.js

@@ -0,0 +1,118 @@
+const { WebBundler } = require('./web-bundler');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('node:path');
+
+async function testWebBundler() {
+  console.log(chalk.cyan.bold('\n🧪 Testing Web Bundler\n'));
+
+  const bundler = new WebBundler();
+  let passedTests = 0;
+  let failedTests = 0;
+
+  // Test 1: Load web activation
+  try {
+    await bundler.loadWebActivation();
+    console.log(chalk.green('✓ Web activation loaded successfully'));
+    passedTests++;
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to load web activation:'), error.message);
+    failedTests++;
+  }
+
+  // Test 2: Discover modules
+  try {
+    const modules = await bundler.discoverModules();
+    console.log(chalk.green(`✓ Discovered ${modules.length} modules:`, modules.join(', ')));
+    passedTests++;
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to discover modules:'), error.message);
+    failedTests++;
+  }
+
+  // Test 3: Bundle analyst agent
+  try {
+    const result = await bundler.bundleAgent('bmm', 'analyst.md');
+
+    // Check if bundle was created
+    const bundlePath = path.join(bundler.outputDir, 'bmm', 'agents', 'analyst.xml');
+    if (await fs.pathExists(bundlePath)) {
+      const content = await fs.readFile(bundlePath, 'utf8');
+
+      // Validate bundle structure
+      const hasAgent = content.includes('<agent');
+      const hasActivation = content.includes('<activation');
+      const hasPersona = content.includes('<persona>');
+      const activationBeforePersona = content.indexOf('<activation') < content.indexOf('<persona>');
+      const hasManifests =
+        content.includes('<agent-party id="bmad/_cfg/agent-party.xml">') && content.includes('<manifest id="bmad/web-manifest.xml">');
+      const hasDependencies = content.includes('<dependencies>');
+
+      console.log(chalk.green('✓ Analyst bundle created successfully'));
+      console.log(chalk.gray(`  - Has agent tag: ${hasAgent ? '✓' : '✗'}`));
+      console.log(chalk.gray(`  - Has activation: ${hasActivation ? '✓' : '✗'}`));
+      console.log(chalk.gray(`  - Has persona: ${hasPersona ? '✓' : '✗'}`));
+      console.log(chalk.gray(`  - Activation before persona: ${activationBeforePersona ? '✓' : '✗'}`));
+      console.log(chalk.gray(`  - Has manifests: ${hasManifests ? '✓' : '✗'}`));
+      console.log(chalk.gray(`  - Has dependencies: ${hasDependencies ? '✓' : '✗'}`));
+
+      if (hasAgent && hasActivation && hasPersona && activationBeforePersona && hasManifests && hasDependencies) {
+        passedTests++;
+      } else {
+        console.error(chalk.red('✗ Bundle structure validation failed'));
+        failedTests++;
+      }
+    } else {
+      console.error(chalk.red('✗ Bundle file not created'));
+      failedTests++;
+    }
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to bundle analyst agent:'), error.message);
+    failedTests++;
+  }
+
+  // Test 4: Bundle a different agent (architect which exists)
+  try {
+    const result = await bundler.bundleAgent('bmm', 'architect.md');
+    const bundlePath = path.join(bundler.outputDir, 'bmm', 'agents', 'architect.xml');
+
+    if (await fs.pathExists(bundlePath)) {
+      console.log(chalk.green('✓ Architect bundle created successfully'));
+      passedTests++;
+    } else {
+      console.error(chalk.red('✗ Architect bundle file not created'));
+      failedTests++;
+    }
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to bundle architect agent:'), error.message);
+    failedTests++;
+  }
+
+  // Test 5: Bundle all agents in a module
+  try {
+    const results = await bundler.bundleModule('bmm');
+    console.log(chalk.green(`✓ Bundled ${results.agents.length} agents from bmm module`));
+    passedTests++;
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to bundle bmm module:'), error.message);
+    failedTests++;
+  }
+
+  // Summary
+  console.log(chalk.bold('\n📊 Test Results:'));
+  console.log(chalk.green(`  Passed: ${passedTests}`));
+  console.log(chalk.red(`  Failed: ${failedTests}`));
+
+  if (failedTests === 0) {
+    console.log(chalk.green.bold('\n✅ All tests passed!\n'));
+  } else {
+    console.log(chalk.red.bold(`\n❌ ${failedTests} test(s) failed\n`));
+    process.exit(1);
+  }
+}
+
+// Run tests
+testWebBundler().catch((error) => {
+  console.error(chalk.red('Fatal error:'), error);
+  process.exit(1);
+});