bmad-fh 6.0.0-alpha.052779ef

package/tools/cli/commands/install.js

@@ -0,0 +1,87 @@
+const chalk = require('chalk');
+const path = require('node:path');
+const { Installer } = require('../installers/lib/core/installer');
+const { UI } = require('../lib/ui');
+
+const installer = new Installer();
+const ui = new UI();
+
+module.exports = {
+  command: 'install',
+  description: 'Install BMAD Core agents and tools',
+  options: [['-d, --debug', 'Enable debug output for manifest generation']],
+  action: async (options) => {
+    try {
+      // Set debug flag as environment variable for all components
+      if (options.debug) {
+        process.env.BMAD_DEBUG_MANIFEST = 'true';
+        console.log(chalk.cyan('Debug mode enabled\n'));
+      }
+
+      const config = await ui.promptInstall();
+
+      // Handle cancel
+      if (config.actionType === 'cancel') {
+        console.log(chalk.yellow('Installation cancelled.'));
+        process.exit(0);
+        return;
+      }
+
+      // Handle quick update separately
+      if (config.actionType === 'quick-update') {
+        const result = await installer.quickUpdate(config);
+        console.log(chalk.green('\n✨ Quick update complete!'));
+        console.log(chalk.cyan(`Updated ${result.moduleCount} modules with preserved settings (${result.modules.join(', ')})`));
+
+        // Display version-specific end message
+        const { MessageLoader } = require('../installers/lib/message-loader');
+        const messageLoader = new MessageLoader();
+        messageLoader.displayEndMessage();
+
+        process.exit(0);
+        return;
+      }
+
+      // Handle compile agents separately
+      if (config.actionType === 'compile-agents') {
+        const result = await installer.compileAgents(config);
+        console.log(chalk.green('\n✨ Agent recompilation complete!'));
+        console.log(chalk.cyan(`Recompiled ${result.agentCount} agents with customizations applied`));
+        process.exit(0);
+        return;
+      }
+
+      // Regular install/update flow
+      const result = await installer.install(config);
+
+      // Check if installation was cancelled
+      if (result && result.cancelled) {
+        process.exit(0);
+        return;
+      }
+
+      // Check if installation succeeded
+      if (result && result.success) {
+        // Display version-specific end message from install-messages.yaml
+        const { MessageLoader } = require('../installers/lib/message-loader');
+        const messageLoader = new MessageLoader();
+        messageLoader.displayEndMessage();
+
+        process.exit(0);
+      }
+    } catch (error) {
+      // Check if error has a complete formatted message
+      if (error.fullMessage) {
+        console.error(error.fullMessage);
+        if (error.stack) {
+          console.error('\n' + chalk.dim(error.stack));
+        }
+      } else {
+        // Generic error handling for all other errors
+        console.error(chalk.red('Installation failed:'), error.message);
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/scope.js

@@ -0,0 +1,474 @@
+const chalk = require('chalk');
+const path = require('node:path');
+const fs = require('fs-extra');
+const { select, text, confirm, isCancel } = require('../lib/prompts');
+
+// Import scope management classes from core lib
+// Note: These will be available after installation in _bmad/core/lib/scope/
+// For CLI, we use them from src during development
+const { ScopeManager } = require('../../../src/core/lib/scope/scope-manager');
+const { ScopeInitializer } = require('../../../src/core/lib/scope/scope-initializer');
+const { ScopeValidator } = require('../../../src/core/lib/scope/scope-validator');
+
+/**
+ * Format a date string for display
+ * @param {string} dateStr - ISO date string
+ * @returns {string} Formatted date
+ */
+function formatDate(dateStr) {
+  if (!dateStr) return 'N/A';
+  const date = new Date(dateStr);
+  return date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+
+/**
+ * Display scope list in a formatted table
+ * @param {object[]} scopes - Array of scope objects
+ */
+function displayScopeList(scopes) {
+  if (scopes.length === 0) {
+    console.log(chalk.yellow('\nNo scopes found. Create one with: bmad scope create <id>\n'));
+    return;
+  }
+
+  console.log(chalk.bold('\n  Scopes:\n'));
+
+  // Calculate column widths
+  const idWidth = Math.max(10, ...scopes.map((s) => s.id.length)) + 2;
+  const nameWidth = Math.max(15, ...scopes.map((s) => (s.name || '').length)) + 2;
+
+  // Header
+  console.log(
+    chalk.dim('  ') +
+      chalk.bold('ID'.padEnd(idWidth)) +
+      chalk.bold('Name'.padEnd(nameWidth)) +
+      chalk.bold('Status'.padEnd(10)) +
+      chalk.bold('Created'),
+  );
+  console.log(chalk.dim('  ' + '─'.repeat(idWidth + nameWidth + 10 + 20)));
+
+  // Rows
+  for (const scope of scopes) {
+    const statusColor = scope.status === 'active' ? chalk.green : chalk.dim;
+    console.log(
+      '  ' +
+        chalk.cyan(scope.id.padEnd(idWidth)) +
+        (scope.name || scope.id).padEnd(nameWidth) +
+        statusColor(scope.status.padEnd(10)) +
+        chalk.dim(formatDate(scope.created).split(' ')[0]),
+    );
+  }
+  console.log();
+}
+
+/**
+ * Display detailed scope info
+ * @param {object} scope - Scope object
+ * @param {object} paths - Scope paths
+ * @param {object} tree - Dependency tree
+ */
+function displayScopeInfo(scope, paths, tree) {
+  console.log(chalk.bold(`\n  Scope: ${scope.name || scope.id}\n`));
+
+  console.log(chalk.dim('  ─────────────────────────────────────'));
+  console.log(`  ${chalk.bold('ID:')}           ${chalk.cyan(scope.id)}`);
+  console.log(`  ${chalk.bold('Name:')}         ${scope.name || 'N/A'}`);
+  console.log(`  ${chalk.bold('Description:')}  ${scope.description || 'No description'}`);
+  console.log(`  ${chalk.bold('Status:')}       ${scope.status === 'active' ? chalk.green('active') : chalk.dim('archived')}`);
+  console.log(`  ${chalk.bold('Created:')}      ${formatDate(scope.created)}`);
+  console.log(`  ${chalk.bold('Last Active:')}  ${formatDate(scope._meta?.last_activity)}`);
+  console.log(`  ${chalk.bold('Artifacts:')}    ${scope._meta?.artifact_count || 0}`);
+
+  console.log(chalk.dim('\n  ─────────────────────────────────────'));
+  console.log(chalk.bold('  Paths:'));
+  console.log(`    Planning:       ${chalk.dim(paths.planning)}`);
+  console.log(`    Implementation: ${chalk.dim(paths.implementation)}`);
+  console.log(`    Tests:          ${chalk.dim(paths.tests)}`);
+
+  console.log(chalk.dim('\n  ─────────────────────────────────────'));
+  console.log(chalk.bold('  Dependencies:'));
+  if (tree.dependencies.length > 0) {
+    for (const dep of tree.dependencies) {
+      const statusIcon = dep.status === 'active' ? chalk.green('●') : chalk.dim('○');
+      console.log(`    ${statusIcon} ${dep.scope} (${dep.name})`);
+    }
+  } else {
+    console.log(chalk.dim('    None'));
+  }
+
+  console.log(chalk.bold('\n  Dependents (scopes that depend on this):'));
+  if (tree.dependents.length > 0) {
+    for (const dep of tree.dependents) {
+      console.log(`    ← ${chalk.cyan(dep)}`);
+    }
+  } else {
+    console.log(chalk.dim('    None'));
+  }
+
+  console.log();
+}
+
+/**
+ * Handle 'list' subcommand
+ */
+async function handleList(projectRoot, options) {
+  const manager = new ScopeManager({ projectRoot });
+
+  try {
+    await manager.initialize();
+    const scopes = await manager.listScopes(options.status ? { status: options.status } : {});
+    displayScopeList(scopes);
+  } catch (error) {
+    if (error.message.includes('does not exist')) {
+      console.log(chalk.yellow('\nScope system not initialized. Run: bmad scope init\n'));
+    } else {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Handle 'create' subcommand
+ */
+async function handleCreate(projectRoot, scopeId, options) {
+  const manager = new ScopeManager({ projectRoot });
+  const initializer = new ScopeInitializer({ projectRoot });
+  const validator = new ScopeValidator();
+
+  // If no scopeId provided, prompt for it
+  if (!scopeId) {
+    const inputId = await text({
+      message: 'Enter scope ID (lowercase, letters/numbers/hyphens):',
+      placeholder: 'e.g., auth, payments, user-service',
+      validate: (value) => {
+        const result = validator.validateScopeId(value);
+        return result.valid ? undefined : result.error;
+      },
+    });
+
+    if (isCancel(inputId)) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+    scopeId = inputId;
+  }
+
+  // Validate scope ID
+  const idValidation = validator.validateScopeId(scopeId);
+  if (!idValidation.valid) {
+    console.error(chalk.red(`Error: ${idValidation.error}`));
+    process.exit(1);
+  }
+
+  // Get scope name if not provided
+  let name = options.name;
+  if (!name) {
+    const inputName = await text({
+      message: 'Enter scope name (human-readable):',
+      placeholder: `e.g., Authentication Service`,
+      initialValue: scopeId.charAt(0).toUpperCase() + scopeId.slice(1).replaceAll('-', ' '),
+    });
+
+    if (isCancel(inputName)) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+    name = inputName;
+  }
+
+  // Get description if not provided
+  let description = options.description;
+  if (!description) {
+    const inputDesc = await text({
+      message: 'Enter scope description (optional):',
+      placeholder: 'Brief description of this scope',
+    });
+
+    if (isCancel(inputDesc)) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+    description = inputDesc || '';
+  }
+
+  console.log(chalk.blue('\nCreating scope...'));
+
+  // Initialize scope system if needed
+  await manager.initialize();
+
+  // Check if system is initialized
+  const systemInit = await initializer.isSystemInitialized();
+  if (!systemInit) {
+    console.log(chalk.blue('Initializing scope system...'));
+    await initializer.initializeScopeSystem();
+  }
+
+  // Create scope in configuration
+  const scope = await manager.createScope(scopeId, {
+    name,
+    description,
+    dependencies: options.dependencies ? options.dependencies.split(',').map((d) => d.trim()) : [],
+  });
+
+  // Create scope directory structure
+  const paths = await initializer.initializeScope(scopeId, {
+    name,
+    description,
+    createContext: options.context,
+  });
+
+  console.log(chalk.green(`\n✓ Scope '${scopeId}' created successfully!\n`));
+  console.log(chalk.dim('  Directories created:'));
+  console.log(`    ${paths.planning}`);
+  console.log(`    ${paths.implementation}`);
+  console.log(`    ${paths.tests}`);
+  console.log();
+  console.log(chalk.cyan(`  Use with: bmad workflow --scope ${scopeId}`));
+  console.log();
+}
+
+/**
+ * Handle 'info' subcommand
+ */
+async function handleInfo(projectRoot, scopeId) {
+  if (!scopeId) {
+    console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope info <scope-id>'));
+    process.exit(1);
+  }
+
+  const manager = new ScopeManager({ projectRoot });
+
+  await manager.initialize();
+  const scope = await manager.getScope(scopeId);
+
+  if (!scope) {
+    console.error(chalk.red(`Error: Scope '${scopeId}' not found.`));
+    process.exit(1);
+  }
+
+  const paths = await manager.getScopePaths(scopeId);
+  const tree = await manager.getDependencyTree(scopeId);
+
+  displayScopeInfo(scope, paths, tree);
+}
+
+/**
+ * Handle 'remove' subcommand
+ */
+async function handleRemove(projectRoot, scopeId, options) {
+  if (!scopeId) {
+    console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope remove <scope-id>'));
+    process.exit(1);
+  }
+
+  const manager = new ScopeManager({ projectRoot });
+  const initializer = new ScopeInitializer({ projectRoot });
+
+  await manager.initialize();
+
+  const scope = await manager.getScope(scopeId);
+  if (!scope) {
+    console.error(chalk.red(`Error: Scope '${scopeId}' not found.`));
+    process.exit(1);
+  }
+
+  // Confirm removal unless --force
+  if (!options.force) {
+    const confirmed = await confirm({
+      message: `Are you sure you want to remove scope '${scopeId}'? This will delete all scope artifacts!`,
+      initialValue: false,
+    });
+
+    if (isCancel(confirmed) || !confirmed) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+  }
+
+  console.log(chalk.blue('\nRemoving scope...'));
+
+  // Remove scope directory (with backup)
+  await initializer.removeScope(scopeId, { backup: !options.noBackup });
+
+  // Remove from configuration
+  await manager.removeScope(scopeId, { force: true });
+
+  console.log(chalk.green(`\n✓ Scope '${scopeId}' removed successfully!`));
+  if (!options.noBackup) {
+    console.log(chalk.dim('  A backup was created in _bmad-output/'));
+  }
+  console.log();
+}
+
+/**
+ * Handle 'init' subcommand - Initialize scope system
+ */
+async function handleInit(projectRoot) {
+  const manager = new ScopeManager({ projectRoot });
+  const initializer = new ScopeInitializer({ projectRoot });
+
+  console.log(chalk.blue('\nInitializing scope system...'));
+
+  await manager.initialize();
+  await initializer.initializeScopeSystem();
+
+  console.log(chalk.green('\n✓ Scope system initialized successfully!\n'));
+  console.log(chalk.dim('  Created:'));
+  console.log(`    ${chalk.cyan('_bmad/_config/scopes.yaml')} - Scope configuration`);
+  console.log(`    ${chalk.cyan('_bmad-output/_shared/')} - Shared knowledge layer`);
+  console.log(`    ${chalk.cyan('_bmad/_events/')} - Event system`);
+  console.log();
+  console.log(chalk.cyan('  Next: bmad scope create <scope-id>'));
+  console.log();
+}
+
+/**
+ * Handle 'archive' subcommand
+ */
+async function handleArchive(projectRoot, scopeId) {
+  if (!scopeId) {
+    console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope archive <scope-id>'));
+    process.exit(1);
+  }
+
+  const manager = new ScopeManager({ projectRoot });
+
+  await manager.initialize();
+  await manager.archiveScope(scopeId);
+
+  console.log(chalk.green(`\n✓ Scope '${scopeId}' archived.\n`));
+}
+
+/**
+ * Handle 'activate' subcommand
+ */
+async function handleActivate(projectRoot, scopeId) {
+  if (!scopeId) {
+    console.error(chalk.red('Error: Scope ID is required. Usage: bmad scope activate <scope-id>'));
+    process.exit(1);
+  }
+
+  const manager = new ScopeManager({ projectRoot });
+
+  await manager.initialize();
+  await manager.activateScope(scopeId);
+
+  console.log(chalk.green(`\n✓ Scope '${scopeId}' activated.\n`));
+}
+
+/**
+ * Show help for scope command
+ */
+function showHelp() {
+  console.log(chalk.bold('\n  BMAD Scope Management\n'));
+  console.log('  Manage isolated artifact scopes for parallel development.\n');
+  console.log(chalk.bold('  Commands:'));
+  console.log(`    ${chalk.cyan('init')}                   Initialize scope system`);
+  console.log(`    ${chalk.cyan('list')}                   List all scopes`);
+  console.log(`    ${chalk.cyan('create')} ${chalk.dim('[id]')}           Create a new scope`);
+  console.log(`    ${chalk.cyan('info')} ${chalk.dim('<id>')}             Show scope details`);
+  console.log(`    ${chalk.cyan('remove')} ${chalk.dim('<id>')}           Remove a scope`);
+  console.log(`    ${chalk.cyan('archive')} ${chalk.dim('<id>')}          Archive a scope`);
+  console.log(`    ${chalk.cyan('activate')} ${chalk.dim('<id>')}         Activate an archived scope`);
+  console.log();
+  console.log(chalk.bold('  Options:'));
+  console.log(`    ${chalk.cyan('-n, --name')} ${chalk.dim('<name>')}      Scope name for create`);
+  console.log(`    ${chalk.cyan('-d, --description')} ${chalk.dim('<desc>')}  Scope description`);
+  console.log(`    ${chalk.cyan('-f, --force')}            Force removal without confirmation`);
+  console.log(`    ${chalk.cyan('--no-backup')}            Don't create backup on remove`);
+  console.log(`    ${chalk.cyan('--context')}              Create scope-specific project-context.md`);
+  console.log();
+  console.log(chalk.bold('  Examples:'));
+  console.log(`    ${chalk.dim('$')} bmad scope init`);
+  console.log(`    ${chalk.dim('$')} bmad scope create auth --name "Authentication"`);
+  console.log(`    ${chalk.dim('$')} bmad scope list`);
+  console.log(`    ${chalk.dim('$')} bmad scope info auth`);
+  console.log(`    ${chalk.dim('$')} bmad scope remove auth --force`);
+  console.log();
+}
+
+module.exports = {
+  command: 'scope [subcommand] [id]',
+  description: 'Manage scopes for parallel artifact isolation',
+  options: [
+    ['-n, --name <name>', 'Scope name (for create)'],
+    ['-d, --description <desc>', 'Scope description'],
+    ['--deps, --dependencies <deps>', 'Comma-separated dependency scope IDs'],
+    ['-f, --force', 'Force operation without confirmation'],
+    ['--no-backup', 'Skip backup on remove'],
+    ['--context', 'Create scope-specific project-context.md'],
+    ['-s, --status <status>', 'Filter by status (active/archived)'],
+  ],
+  action: async (subcommand, id, options) => {
+    try {
+      // Determine project root
+      const projectRoot = process.cwd();
+
+      // Handle subcommands
+      switch (subcommand) {
+        case 'init': {
+          await handleInit(projectRoot);
+          break;
+        }
+
+        case 'list':
+        case 'ls': {
+          await handleList(projectRoot, options);
+          break;
+        }
+
+        case 'create':
+        case 'new': {
+          await handleCreate(projectRoot, id, options);
+          break;
+        }
+
+        case 'info':
+        case 'show': {
+          await handleInfo(projectRoot, id);
+          break;
+        }
+
+        case 'remove':
+        case 'rm':
+        case 'delete': {
+          await handleRemove(projectRoot, id, options);
+          break;
+        }
+
+        case 'archive': {
+          await handleArchive(projectRoot, id);
+          break;
+        }
+
+        case 'activate': {
+          await handleActivate(projectRoot, id);
+          break;
+        }
+
+        case 'help':
+        case undefined: {
+          showHelp();
+          break;
+        }
+
+        default: {
+          // If subcommand looks like an ID, show info for it
+          if (subcommand && !subcommand.startsWith('-')) {
+            await handleInfo(projectRoot, subcommand);
+          } else {
+            showHelp();
+          }
+        }
+      }
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red(`\nError: ${error.message}`));
+      if (process.env.DEBUG) {
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/external-official-modules.yaml

@@ -0,0 +1,41 @@
+# This file allows these modules under bmad-code-org to also be installed with the bmad method installer, while
+# allowing us to keep the source of these projects in separate repos.
+
+modules:
+  bmad-builder:
+    url: https://github.com/bmad-code-org/bmad-builder
+    module-definition: src/module.yaml
+    code: bmb
+    name: "BMad Builder"
+    description: "Agent, Workflow and Module Builder"
+    defaultSelected: false
+    type: bmad-org
+
+  bmad-creative-intelligence-suite:
+    url: https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite
+    module-definition: src/module.yaml
+    code: cis
+    name: "BMad Creative Innovation Suite"
+    description: "Creative tools for writing, brainstorming, and more"
+    defaultSelected: false
+    type: bmad-org
+
+  bmad-game-dev-studio:
+    url: https://github.com/bmad-code-org/bmad-module-game-dev-studio.git
+    module-definition: src/module.yaml
+    code: gds
+    name: "BMad Game Dev Suite"
+    description: "Game development agents and workflows"
+    defaultSelected: false
+    type: bmad-org
+
+# TODO: Enable once fixes applied:
+
+# whiteport-design-system:
+#   url: https://github.com/bmad-code-org/bmad-method-wds-expansion
+#   module-definition: src/module.yaml
+#   code: WDS
+#   name: "Whiteport UX Design System"
+#   description: "UX design framework with Figma integration"
+#   defaultSelected: false
+#   type: community

package/tools/cli/installers/install-messages.yaml

@@ -0,0 +1,58 @@
+# BMAD Installer Messages
+# These messages are displayed during installation
+# Edit this file to change what users see during the install process
+
+# Display at the START of installation (after logo, before prompts)
+startMessage: |
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ⭐ IMPORTANT: Version Alpha.23 Changes
+
+  If your current version is older than Alpha.21, you'll need a fresh install:
+    - Remove .bmad folder and reinstall
+    - Only needed during final push to beta (ETA January 18th)
+
+  📚 New Docs Site: http://docs.bmad-method.org/
+    - Tons of guides and articles coming soon!
+    - Everything is free. No paywalls. No gated content.
+    - Knowledge should be shared, not sold.
+
+  📺 YouTube Master Class & Podcast launching February 1st!
+
+  💡 Love BMad? Please star us on GitHub & subscribe on YouTube!
+    - GitHub: https://github.com/bmad-code-org/BMAD-METHOD/
+    - YouTube: https://www.youtube.com/@BMadCode
+
+  Latest updates: https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CHANGELOG.md
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# Display at the END of installation (after all setup completes)
+endMessage: |
+  ════════════════════════════════════════════════════════════════════════════════
+
+  ✨ BMAD IS READY! Beta is just days away! Thank you for your support!
+
+  🌟 BMad is 100% free and open source.
+    - No gated Discord. No paywalls.
+    - We believe in empowering everyone, not just those who can pay.
+
+  🙏 SUPPORT BMAD DEVELOPMENT:
+    - Donate: https://buymeacoffee.com/bmad
+    - Corporate Sponsorship available - DM on Discord
+
+  🎤 SPEAKING & MEDIA:
+    - Available for conferences, podcasts, and media appearances
+    - Topics: AI-Native Transformation, Spec and Context Engineering, BMad Method
+    - For speaking inquiries or interviews, reach out to BMad on Discord!
+
+  📚 RESOURCES:
+    - Docs: http://docs.bmad-method.org/ (bookmark it!)
+    - Changelog: https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CHANGELOG.md
+
+  ⭐⭐⭐ HELP US GROW:
+    - Star us on GitHub: https://github.com/bmad-code-org/BMAD-METHOD/
+    - Subscribe on YouTube: https://www.youtube.com/@BMadCode
+    - Every star & sub helps us reach more developers!
+
+  ════════════════════════════════════════════════════════════════════════════════