bmad-stella 1.0.0

package/tools/bump-all-versions.js

@@ -0,0 +1,115 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const yaml = require('js-yaml');
+
+const arguments_ = process.argv.slice(2);
+const bumpType = arguments_[0] || 'minor'; // default to minor
+
+if (!['major', 'minor', 'patch'].includes(bumpType)) {
+  console.log('Usage: node bump-all-versions.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 bumpAllVersions() {
+  const updatedItems = [];
+
+  // First, bump the core version (package.json)
+  const packagePath = path.join(__dirname, '..', 'package.json');
+  try {
+    const packageContent = fs.readFileSync(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageContent);
+    const oldCoreVersion = packageJson.version || '1.0.0';
+    const newCoreVersion = bumpVersion(oldCoreVersion, bumpType);
+
+    packageJson.version = newCoreVersion;
+
+    fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2) + '\n');
+
+    updatedItems.push({
+      type: 'core',
+      name: 'BMad Core',
+      oldVersion: oldCoreVersion,
+      newVersion: newCoreVersion,
+    });
+    console.log(`✓ BMad Core (package.json): ${oldCoreVersion} → ${newCoreVersion}`);
+  } catch (error) {
+    console.error(`✗ Failed to update BMad Core: ${error.message}`);
+  }
+
+  // Then, bump all expansion packs
+  const expansionPacksDir = path.join(__dirname, '..', 'expansion-packs');
+
+  try {
+    const entries = fs.readdirSync(expansionPacksDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'README.md') {
+        const packId = entry.name;
+        const configPath = path.join(expansionPacksDir, packId, 'config.yaml');
+
+        if (fs.existsSync(configPath)) {
+          try {
+            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);
+
+            updatedItems.push({ type: 'expansion', name: packId, oldVersion, newVersion });
+            console.log(`✓ ${packId}: ${oldVersion} → ${newVersion}`);
+          } catch (error) {
+            console.error(`✗ Failed to update ${packId}: ${error.message}`);
+          }
+        }
+      }
+    }
+
+    if (updatedItems.length > 0) {
+      const coreCount = updatedItems.filter((index) => index.type === 'core').length;
+      const expansionCount = updatedItems.filter((index) => index.type === 'expansion').length;
+
+      console.log(
+        `\n✓ Successfully bumped ${updatedItems.length} item(s) with ${bumpType} version bump`,
+      );
+      if (coreCount > 0) console.log(`  - ${coreCount} core`);
+      if (expansionCount > 0) console.log(`  - ${expansionCount} expansion pack(s)`);
+
+      console.log('\nNext steps:');
+      console.log('1. Test the changes');
+      console.log(
+        '2. Commit: git add -A && git commit -m "chore: bump all versions (' + bumpType + ')"',
+      );
+    } else {
+      console.log('No items found to update');
+    }
+  } catch (error) {
+    console.error('Error reading expansion packs directory:', error.message);
+    process.exit(1);
+  }
+}
+
+bumpAllVersions();

package/tools/bump-expansion-version.js

@@ -0,0 +1,90 @@
+// Load required modules
+const fs = require('node:fs');
+const path = require('node:path');
+const yaml = require('js-yaml');
+
+// Parse CLI arguments
+const arguments_ = process.argv.slice(2);
+const packId = arguments_[0];
+const bumpType = arguments_[1] || 'minor';
+
+// Validate arguments
+if (!packId || arguments_.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);
+}
+
+if (!['major', 'minor', 'patch'].includes(bumpType)) {
+  console.error('Error: Bump type must be major, minor, or patch');
+  process.exit(1);
+}
+
+// Version bump logic
+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;
+    }
+  }
+}
+
+// Main function to bump version
+async function updateVersion() {
+  const configPath = path.join(__dirname, '..', 'expansion-packs', packId, 'config.yaml');
+
+  // Check if config exists
+  if (!fs.existsSync(configPath)) {
+    console.error(`Error: Expansion pack '${packId}' not found`);
+    console.log('\nAvailable expansion packs:');
+
+    const packsDir = path.join(__dirname, '..', 'expansion-packs');
+    const entries = fs.readdirSync(packsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        console.log(`  - ${entry.name}`);
+      }
+    }
+
+    process.exit(1);
+  }
+
+  try {
+    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/cli.js

@@ -0,0 +1,152 @@
+const { Command } = require('commander');
+const WebBuilder = require('./builders/web-builder');
+const V3ToV4Upgrader = require('./upgraders/v3-to-v4-upgrader');
+const IdeSetup = require('./installer/lib/ide-setup');
+const path = require('node:path');
+
+const program = new Command();
+
+program
+  .name('bmad-build')
+  .description('BMAD-METHOD™ build tool for creating web bundles')
+  .version('4.0.0');
+
+program
+  .command('build')
+  .description('Build web bundles for agents and teams')
+  .option('-a, --agents-only', 'Build only agent bundles')
+  .option('-t, --teams-only', 'Build only team bundles')
+  .option('-e, --expansions-only', 'Build only expansion pack bundles')
+  .option('--no-expansions', 'Skip building expansion packs')
+  .option('--no-clean', 'Skip cleaning output directories')
+  .action(async (options) => {
+    const builder = new WebBuilder({
+      rootDir: process.cwd(),
+    });
+
+    try {
+      if (options.clean) {
+        console.log('Cleaning output directories...');
+        await builder.cleanOutputDirs();
+      }
+
+      if (options.expansionsOnly) {
+        console.log('Building expansion pack bundles...');
+        await builder.buildAllExpansionPacks({ clean: false });
+      } else {
+        if (!options.teamsOnly) {
+          console.log('Building agent bundles...');
+          await builder.buildAgents();
+        }
+
+        if (!options.agentsOnly) {
+          console.log('Building team bundles...');
+          await builder.buildTeams();
+        }
+
+        if (!options.noExpansions) {
+          console.log('Building expansion pack bundles...');
+          await builder.buildAllExpansionPacks({ clean: false });
+        }
+      }
+
+      console.log('Build completed successfully!');
+    } catch (error) {
+      console.error('Build failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('build:expansions')
+  .description('Build web bundles for all expansion packs')
+  .option('--expansion <name>', 'Build specific expansion pack only')
+  .option('--no-clean', 'Skip cleaning output directories')
+  .action(async (options) => {
+    const builder = new WebBuilder({
+      rootDir: process.cwd(),
+    });
+
+    try {
+      if (options.expansion) {
+        console.log(`Building expansion pack: ${options.expansion}`);
+        await builder.buildExpansionPack(options.expansion, { clean: options.clean });
+      } else {
+        console.log('Building all expansion packs...');
+        await builder.buildAllExpansionPacks({ clean: options.clean });
+      }
+
+      console.log('Expansion pack build completed successfully!');
+    } catch (error) {
+      console.error('Expansion pack build failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list:agents')
+  .description('List all available agents')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    const agents = await builder.resolver.listAgents();
+    console.log('Available agents:');
+    for (const agent of agents) console.log(`  - ${agent}`);
+    process.exit(0);
+  });
+
+program
+  .command('list:expansions')
+  .description('List all available expansion packs')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    const expansions = await builder.listExpansionPacks();
+    console.log('Available expansion packs:');
+    for (const expansion of expansions) console.log(`  - ${expansion}`);
+    process.exit(0);
+  });
+
+program
+  .command('validate')
+  .description('Validate agent and team configurations')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    try {
+      // Validate by attempting to build all agents and teams
+      const agents = await builder.resolver.listAgents();
+      const teams = await builder.resolver.listTeams();
+
+      console.log('Validating agents...');
+      for (const agent of agents) {
+        await builder.resolver.resolveAgentDependencies(agent);
+        console.log(`  ✓ ${agent}`);
+      }
+
+      console.log('\nValidating teams...');
+      for (const team of teams) {
+        await builder.resolver.resolveTeamDependencies(team);
+        console.log(`  ✓ ${team}`);
+      }
+
+      console.log('\nAll configurations are valid!');
+    } catch (error) {
+      console.error('Validation failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('upgrade')
+  .description('Upgrade a BMAD-METHOD™ V3 project to V4')
+  .option('-p, --project <path>', 'Path to V3 project (defaults to current directory)')
+  .option('--dry-run', 'Show what would be changed without making changes')
+  .option('--no-backup', 'Skip creating backup (not recommended)')
+  .action(async (options) => {
+    const upgrader = new V3ToV4Upgrader();
+    await upgrader.upgrade({
+      projectPath: options.project,
+      dryRun: options.dryRun,
+      backup: options.backup,
+    });
+  });
+
+program.parse();

package/tools/flattener/aggregate.js

@@ -0,0 +1,76 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const os = require('node:os');
+const { isBinaryFile } = require('./binary.js');
+
+/**
+ * Aggregate file contents with bounded concurrency.
+ * Returns text files, binary files (with size), and errors.
+ * @param {string[]} files absolute file paths
+ * @param {string} rootDir
+ * @param {{ text?: string, warn?: (msg: string) => void } | null} spinner
+ */
+async function aggregateFileContents(files, rootDir, spinner = null) {
+  const results = {
+    textFiles: [],
+    binaryFiles: [],
+    errors: [],
+    totalFiles: files.length,
+    processedFiles: 0,
+  };
+
+  // Automatic concurrency selection based on CPU count and workload size.
+  // - Base on 2x logical CPUs, clamped to [2, 64]
+  // - For very small workloads, avoid excessive parallelism
+  const cpuCount = os.cpus && Array.isArray(os.cpus()) ? os.cpus().length : os.cpus?.length || 4;
+  let concurrency = Math.min(64, Math.max(2, (Number(cpuCount) || 4) * 2));
+  if (files.length > 0 && files.length < concurrency) {
+    concurrency = Math.max(1, Math.min(concurrency, Math.ceil(files.length / 2)));
+  }
+
+  async function processOne(filePath) {
+    try {
+      const relativePath = path.relative(rootDir, filePath);
+      if (spinner) {
+        spinner.text = `Processing: ${relativePath} (${results.processedFiles + 1}/${results.totalFiles})`;
+      }
+
+      const binary = await isBinaryFile(filePath);
+      if (binary) {
+        const { size } = await fs.stat(filePath);
+        results.binaryFiles.push({ path: relativePath, absolutePath: filePath, size });
+      } else {
+        const content = await fs.readFile(filePath, 'utf8');
+        results.textFiles.push({
+          path: relativePath,
+          absolutePath: filePath,
+          content,
+          size: content.length,
+          lines: content.split('\n').length,
+        });
+      }
+    } catch (error) {
+      const relativePath = path.relative(rootDir, filePath);
+      const errorInfo = { path: relativePath, absolutePath: filePath, error: error.message };
+      results.errors.push(errorInfo);
+      if (spinner) {
+        spinner.warn(`Warning: Could not read file ${relativePath}: ${error.message}`);
+      } else {
+        console.warn(`Warning: Could not read file ${relativePath}: ${error.message}`);
+      }
+    } finally {
+      results.processedFiles++;
+    }
+  }
+
+  for (let index = 0; index < files.length; index += concurrency) {
+    const slice = files.slice(index, index + concurrency);
+    await Promise.all(slice.map(processOne));
+  }
+
+  return results;
+}
+
+module.exports = {
+  aggregateFileContents,
+};

package/tools/flattener/binary.js

@@ -0,0 +1,80 @@
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { Buffer } = require('node:buffer');
+
+/**
+ * Efficiently determine if a file is binary without reading the whole file.
+ * - Fast path by extension for common binaries
+ * - Otherwise read a small prefix and check for NUL bytes
+ * @param {string} filePath
+ * @returns {Promise<boolean>}
+ */
+async function isBinaryFile(filePath) {
+  try {
+    const stats = await fsp.stat(filePath);
+    if (stats.isDirectory()) {
+      throw new Error('EISDIR: illegal operation on a directory');
+    }
+
+    const binaryExtensions = new Set([
+      '.jpg',
+      '.jpeg',
+      '.png',
+      '.gif',
+      '.bmp',
+      '.ico',
+      '.svg',
+      '.pdf',
+      '.doc',
+      '.docx',
+      '.xls',
+      '.xlsx',
+      '.ppt',
+      '.pptx',
+      '.zip',
+      '.tar',
+      '.gz',
+      '.rar',
+      '.7z',
+      '.exe',
+      '.dll',
+      '.so',
+      '.dylib',
+      '.mp3',
+      '.mp4',
+      '.avi',
+      '.mov',
+      '.wav',
+      '.ttf',
+      '.otf',
+      '.woff',
+      '.woff2',
+      '.bin',
+      '.dat',
+      '.db',
+      '.sqlite',
+    ]);
+
+    const extension = path.extname(filePath).toLowerCase();
+    if (binaryExtensions.has(extension)) return true;
+    if (stats.size === 0) return false;
+
+    const sampleSize = Math.min(4096, stats.size);
+    const fd = await fsp.open(filePath, 'r');
+    try {
+      const buffer = Buffer.allocUnsafe(sampleSize);
+      const { bytesRead } = await fd.read(buffer, 0, sampleSize, 0);
+      const slice = bytesRead === sampleSize ? buffer : buffer.subarray(0, bytesRead);
+      return slice.includes(0);
+    } finally {
+      await fd.close();
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not determine if file is binary: ${filePath} - ${error.message}`);
+    return false;
+  }
+}
+
+module.exports = {
+  isBinaryFile,
+};

package/tools/flattener/discovery.js

@@ -0,0 +1,71 @@
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const { glob } = require('glob');
+const { loadIgnore } = require('./ignoreRules.js');
+
+const pExecFile = promisify(execFile);
+
+async function isGitRepo(rootDir) {
+  try {
+    const { stdout } = await pExecFile('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: rootDir,
+    });
+    return (
+      String(stdout || '')
+        .toString()
+        .trim() === 'true'
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function gitListFiles(rootDir) {
+  try {
+    const { stdout } = await pExecFile('git', ['ls-files', '-co', '--exclude-standard'], {
+      cwd: rootDir,
+    });
+    return String(stdout || '')
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Discover files under rootDir.
+ * - Prefer git ls-files when available for speed/correctness
+ * - Fallback to glob and apply unified ignore rules
+ * @param {string} rootDir
+ * @param {object} [options]
+ * @param {boolean} [options.preferGit=true]
+ * @returns {Promise<string[]>} absolute file paths
+ */
+async function discoverFiles(rootDir, options = {}) {
+  const { preferGit = true } = options;
+  const { filter } = await loadIgnore(rootDir);
+
+  // Try git first
+  if (preferGit && (await isGitRepo(rootDir))) {
+    const relFiles = await gitListFiles(rootDir);
+    const filteredRel = relFiles.filter((p) => filter(p));
+    return filteredRel.map((p) => path.resolve(rootDir, p));
+  }
+
+  // Glob fallback
+  const globbed = await glob('**/*', {
+    cwd: rootDir,
+    nodir: true,
+    dot: true,
+    follow: false,
+  });
+  const filteredRel = globbed.filter((p) => filter(p));
+  return filteredRel.map((p) => path.resolve(rootDir, p));
+}
+
+module.exports = {
+  discoverFiles,
+};

package/tools/flattener/files.js

@@ -0,0 +1,35 @@
+const path = require('node:path');
+const discovery = require('./discovery.js');
+const ignoreRules = require('./ignoreRules.js');
+const { isBinaryFile } = require('./binary.js');
+const { aggregateFileContents } = require('./aggregate.js');
+
+// Backward-compatible signature; delegate to central loader
+async function parseGitignore(gitignorePath) {
+  return await ignoreRules.parseGitignore(gitignorePath);
+}
+
+async function discoverFiles(rootDir) {
+  try {
+    // Delegate to discovery module which respects .gitignore and defaults
+    return await discovery.discoverFiles(rootDir, { preferGit: true });
+  } catch (error) {
+    console.error('Error discovering files:', error.message);
+    return [];
+  }
+}
+
+async function filterFiles(files, rootDir) {
+  const { filter } = await ignoreRules.loadIgnore(rootDir);
+  const relativeFiles = files.map((f) => path.relative(rootDir, f));
+  const filteredRelative = relativeFiles.filter((p) => filter(p));
+  return filteredRelative.map((p) => path.resolve(rootDir, p));
+}
+
+module.exports = {
+  parseGitignore,
+  discoverFiles,
+  isBinaryFile,
+  aggregateFileContents,
+  filterFiles,
+};