bmad-method 6.0.0-alpha.9 → 6.0.1

package/tools/cli/lib/replace-project-root.js

@@ -1,239 +0,0 @@
-/**
- * Utility function to replace {project-root} placeholders with actual installation target
- * Used during BMAD installation to set correct paths in agent and task files
- */
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-/**
- * Replace {project-root} and {output_folder}/ placeholders in a single file
- * @param {string} filePath - Path to the file to process
- * @param {string} projectRoot - The actual project root path to substitute (must include trailing slash)
- * @param {string} docOut - The document output path (with leading slash)
- * @param {boolean} removeCompletely - If true, removes placeholders entirely instead of replacing
- * @returns {boolean} - True if replacements were made, false otherwise
- */
-function replacePlaceholdersInFile(filePath, projectRoot, docOut = '/docs', removeCompletely = false) {
-  try {
-    let content = fs.readFileSync(filePath, 'utf8');
-    const originalContent = content;
-
-    if (removeCompletely) {
-      // Remove placeholders entirely (for bundling)
-      content = content.replaceAll('{project-root}', '');
-      content = content.replaceAll('{output_folder}/', '');
-    } else {
-      // Handle the combined pattern first to avoid double slashes
-      if (projectRoot && docOut) {
-        // Replace {project-root}{output_folder}/ combinations first
-        // Remove leading slash from docOut since projectRoot has trailing slash
-        // Add trailing slash to docOut
-        const docOutNoLeadingSlash = docOut.replace(/^\//, '');
-        const docOutWithTrailingSlash = docOutNoLeadingSlash.endsWith('/') ? docOutNoLeadingSlash : docOutNoLeadingSlash + '/';
-        content = content.replaceAll('{project-root}{output_folder}/', projectRoot + docOutWithTrailingSlash);
-      }
-
-      // Then replace remaining individual placeholders
-      if (projectRoot) {
-        content = content.replaceAll('{project-root}', projectRoot);
-      }
-
-      if (docOut) {
-        // For standalone {output_folder}/, keep the leading slash and add trailing slash
-        const docOutWithTrailingSlash = docOut.endsWith('/') ? docOut : docOut + '/';
-        content = content.replaceAll('{output_folder}/', docOutWithTrailingSlash);
-      }
-    }
-
-    if (content !== originalContent) {
-      fs.writeFileSync(filePath, content, 'utf8');
-      return true;
-    }
-
-    return false;
-  } catch (error) {
-    console.error(`Error processing file ${filePath}:`, error.message);
-    return false;
-  }
-}
-
-/**
- * Legacy function name for backward compatibility
- */
-function replaceProjectRootInFile(filePath, projectRoot, removeCompletely = false) {
-  return replacePlaceholdersInFile(filePath, projectRoot, '/docs', removeCompletely);
-}
-
-/**
- * Recursively replace {project-root} and {output_folder}/ in all files in a directory
- * @param {string} dirPath - Directory to process
- * @param {string} projectRoot - The actual project root path to substitute (or null to remove)
- * @param {string} docOut - The document output path (with leading slash)
- * @param {Array<string>} extensions - File extensions to process (default: ['.md', '.xml', '.yaml'])
- * @param {boolean} removeCompletely - If true, removes placeholders entirely instead of replacing
- * @param {boolean} verbose - If true, show detailed output for each file
- * @returns {Object} - Stats object with counts of files processed and modified
- */
-function replacePlaceholdersInDirectory(
-  dirPath,
-  projectRoot,
-  docOut = '/docs',
-  extensions = ['.md', '.xml', '.yaml'],
-  removeCompletely = false,
-  verbose = false,
-) {
-  const stats = {
-    processed: 0,
-    modified: 0,
-    errors: 0,
-  };
-
-  function processDirectory(currentPath) {
-    try {
-      const items = fs.readdirSync(currentPath, { withFileTypes: true });
-
-      for (const item of items) {
-        const fullPath = path.join(currentPath, item.name);
-
-        if (item.isDirectory()) {
-          // Skip node_modules and .git directories
-          if (item.name !== 'node_modules' && item.name !== '.git') {
-            processDirectory(fullPath);
-          }
-        } else if (item.isFile()) {
-          // Check if file has one of the target extensions
-          const ext = path.extname(item.name).toLowerCase();
-          if (extensions.includes(ext)) {
-            stats.processed++;
-            if (replacePlaceholdersInFile(fullPath, projectRoot, docOut, removeCompletely)) {
-              stats.modified++;
-              if (verbose) {
-                console.log(`✓ Updated: ${fullPath}`);
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      console.error(`Error processing directory ${currentPath}:`, error.message);
-      stats.errors++;
-    }
-  }
-
-  processDirectory(dirPath);
-  return stats;
-}
-
-/**
- * Legacy function for backward compatibility
- */
-function replaceProjectRootInDirectory(dirPath, projectRoot, extensions = ['.md', '.xml'], removeCompletely = false) {
-  return replacePlaceholdersInDirectory(dirPath, projectRoot, '/docs', extensions, removeCompletely);
-}
-
-/**
- * Replace placeholders in a list of specific files
- * @param {Array<string>} filePaths - Array of file paths to process
- * @param {string} projectRoot - The actual project root path to substitute (or null to remove)
- * @param {string} docOut - The document output path (with leading slash)
- * @param {boolean} removeCompletely - If true, removes placeholders entirely instead of replacing
- * @returns {Object} - Stats object with counts of files processed and modified
- */
-function replacePlaceholdersInFiles(filePaths, projectRoot, docOut = '/docs', removeCompletely = false) {
-  const stats = {
-    processed: 0,
-    modified: 0,
-    errors: 0,
-  };
-
-  for (const filePath of filePaths) {
-    stats.processed++;
-    try {
-      if (replacePlaceholdersInFile(filePath, projectRoot, docOut, removeCompletely)) {
-        stats.modified++;
-        console.log(`✓ Updated: ${filePath}`);
-      }
-    } catch (error) {
-      console.error(`Error processing file ${filePath}:`, error.message);
-      stats.errors++;
-    }
-  }
-
-  return stats;
-}
-
-/**
- * Legacy function for backward compatibility
- */
-function replaceProjectRootInFiles(filePaths, projectRoot, removeCompletely = false) {
-  return replacePlaceholdersInFiles(filePaths, projectRoot, '/docs', removeCompletely);
-}
-
-/**
- * Main installation helper - replaces {project-root} and {output_folder}/ during BMAD installation
- * @param {string} installPath - Path where BMAD is being installed
- * @param {string} targetProjectRoot - The project root to set in the files (slash will be added)
- * @param {string} docsOutputPath - The documentation output path (relative to project root)
- * @param {boolean} verbose - If true, show detailed output
- * @returns {Object} - Installation stats
- */
-function processInstallation(installPath, targetProjectRoot, docsOutputPath = 'docs', verbose = false) {
-  // Ensure project root has trailing slash since usage is like {project-root}/bmad
-  const projectRootWithSlash = targetProjectRoot.endsWith('/') ? targetProjectRoot : targetProjectRoot + '/';
-
-  // Ensure docs path has leading slash (for internal use) but will add trailing slash during replacement
-  const normalizedDocsPath = docsOutputPath.replaceAll(/^\/+|\/+$/g, '');
-  const docOutPath = normalizedDocsPath ? `/${normalizedDocsPath}` : '/docs';
-
-  if (verbose) {
-    console.log(`\nReplacing {project-root} with: ${projectRootWithSlash}`);
-    console.log(`Replacing {output_folder}/ with: ${docOutPath}/`);
-    console.log(`Processing files in: ${installPath}\n`);
-  }
-
-  const stats = replacePlaceholdersInDirectory(installPath, projectRootWithSlash, docOutPath, ['.md', '.xml', '.yaml'], false, verbose);
-
-  if (verbose) {
-    console.log('\n--- Installation Processing Complete ---');
-  }
-  console.log(`Files processed: ${stats.processed}`);
-  console.log(`Files modified: ${stats.modified}`);
-  if (stats.errors > 0) {
-    console.log(`Errors encountered: ${stats.errors}`);
-  }
-
-  return stats;
-}
-
-/**
- * Bundle helper - removes {project-root}/ references for web bundling
- * @param {string} bundlePath - Path where files are being bundled
- * @returns {Object} - Bundle stats
- */
-function processBundleRemoval(bundlePath) {
-  console.log(`\nRemoving {project-root}/ references for bundling`);
-  console.log(`Processing files in: ${bundlePath}\n`);
-
-  const stats = replaceProjectRootInDirectory(bundlePath, null, ['.md', '.xml'], true);
-
-  console.log('\n--- Bundle Processing Complete ---');
-  console.log(`Files processed: ${stats.processed}`);
-  console.log(`Files modified: ${stats.modified}`);
-  if (stats.errors > 0) {
-    console.log(`Errors encountered: ${stats.errors}`);
-  }
-
-  return stats;
-}
-
-module.exports = {
-  replacePlaceholdersInFile,
-  replacePlaceholdersInDirectory,
-  replacePlaceholdersInFiles,
-  replaceProjectRootInFile,
-  replaceProjectRootInDirectory,
-  replaceProjectRootInFiles,
-  processInstallation,
-  processBundleRemoval,
-};

package/tools/cli/regenerate-manifests.js

@@ -1,28 +0,0 @@
-const path = require('node:path');
-const { ManifestGenerator } = require('./installers/lib/core/manifest-generator');
-
-async function regenerateManifests() {
-  const generator = new ManifestGenerator();
-  const targetDir = process.argv[2] || 'z1';
-  const bmadDir = path.join(process.cwd(), targetDir, 'bmad');
-
-  // List of modules to include in manifests
-  const selectedModules = ['bmb', 'bmm', 'cis'];
-
-  console.log('Regenerating manifests with relative paths...');
-  console.log('Target directory:', bmadDir);
-
-  try {
-    const result = await generator.generateManifests(bmadDir, selectedModules, [], { ides: [] });
-    console.log('✓ Manifests generated successfully:');
-    console.log(`  - ${result.workflows} workflows`);
-    console.log(`  - ${result.agents} agents`);
-    console.log(`  - ${result.tasks} tasks`);
-    console.log(`  - ${result.files} files in files-manifest.csv`);
-  } catch (error) {
-    console.error('Error generating manifests:', error);
-    process.exit(1);
-  }
-}
-
-regenerateManifests();

package/tools/cli/test-yaml-builder.js

@@ -1,43 +0,0 @@
-/**
- * Test script for YAML → XML agent builder
- * Usage: node tools/cli/test-yaml-builder.js
- */
-
-const path = require('node:path');
-const { YamlXmlBuilder } = require('./lib/yaml-xml-builder');
-const { getProjectRoot } = require('./lib/project-root');
-
-async function test() {
-  console.log('Testing YAML → XML Agent Builder\n');
-
-  const builder = new YamlXmlBuilder();
-  const projectRoot = getProjectRoot();
-
-  // Paths
-  const agentYamlPath = path.join(projectRoot, 'src/modules/bmm/agents/pm.agent.yaml');
-  const outputPath = path.join(projectRoot, 'test-output-pm.md');
-
-  console.log(`Source: ${agentYamlPath}`);
-  console.log(`Output: ${outputPath}\n`);
-
-  try {
-    const result = await builder.buildAgent(
-      agentYamlPath,
-      null, // No customize file for this test
-      outputPath,
-      { includeMetadata: true },
-    );
-
-    console.log('✓ Build successful!');
-    console.log(`  Output: ${result.outputPath}`);
-    console.log(`  Source hash: ${result.sourceHash}`);
-    console.log('\nGenerated XML file at:', outputPath);
-    console.log('Review the output to verify correctness.\n');
-  } catch (error) {
-    console.error('✗ Build failed:', error.message);
-    console.error(error.stack);
-    process.exit(1);
-  }
-}
-
-test();

package/tools/flattener/aggregate.js

@@ -1,76 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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,
-};