bmad-method 4.35.2 → 4.36.0

package/tools/flattener/projectRoot.js

@@ -0,0 +1,45 @@
+const fs = require("fs-extra");
+const path = require("node:path");
+
+/**
+ * Attempt to find the project root by walking up from startDir
+ * Looks for common project markers like .git, package.json, pyproject.toml, etc.
+ * @param {string} startDir
+ * @returns {Promise<string|null>} project root directory or null if not found
+ */
+async function findProjectRoot(startDir) {
+  try {
+    let dir = path.resolve(startDir);
+    const root = path.parse(dir).root;
+    const markers = [
+      ".git",
+      "package.json",
+      "pnpm-workspace.yaml",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "pyproject.toml",
+      "requirements.txt",
+      "go.mod",
+      "Cargo.toml",
+      "composer.json",
+      ".hg",
+      ".svn",
+    ];
+
+    while (true) {
+      const exists = await Promise.all(
+        markers.map((m) => fs.pathExists(path.join(dir, m))),
+      );
+      if (exists.some(Boolean)) {
+        return dir;
+      }
+      if (dir === root) break;
+      dir = path.dirname(dir);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { findProjectRoot };

package/tools/flattener/prompts.js

@@ -0,0 +1,44 @@
+const os = require("node:os");
+const path = require("node:path");
+const readline = require("node:readline");
+const process = require("node:process");
+
+function expandHome(p) {
+  if (!p) return p;
+  if (p.startsWith("~")) return path.join(os.homedir(), p.slice(1));
+  return p;
+}
+
+function createRl() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+function promptQuestion(question) {
+  return new Promise((resolve) => {
+    const rl = createRl();
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+async function promptYesNo(question, defaultYes = true) {
+  const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+  const ans = (await promptQuestion(`${question}${suffix}`)).trim().toLowerCase();
+  if (!ans) return defaultYes;
+  if (["y", "yes"].includes(ans)) return true;
+  if (["n", "no"].includes(ans)) return false;
+  return promptYesNo(question, defaultYes);
+}
+
+async function promptPath(question, defaultValue) {
+  const prompt = `${question}${defaultValue ? ` (default: ${defaultValue})` : ""}: `;
+  const ans = (await promptQuestion(prompt)).trim();
+  return expandHome(ans || defaultValue);
+}
+
+module.exports = { promptYesNo, promptPath, promptQuestion, expandHome };

package/tools/flattener/stats.js

@@ -0,0 +1,30 @@
+function calculateStatistics(aggregatedContent, xmlFileSize) {
+  const { textFiles, binaryFiles, errors } = aggregatedContent;
+
+  const totalTextSize = textFiles.reduce((sum, file) => sum + file.size, 0);
+  const totalBinarySize = binaryFiles.reduce((sum, file) => sum + file.size, 0);
+  const totalSize = totalTextSize + totalBinarySize;
+
+  const totalLines = textFiles.reduce((sum, file) => sum + file.lines, 0);
+
+  const estimatedTokens = Math.ceil(xmlFileSize / 4);
+
+  const formatSize = (bytes) => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  };
+
+  return {
+    totalFiles: textFiles.length + binaryFiles.length,
+    textFiles: textFiles.length,
+    binaryFiles: binaryFiles.length,
+    errorFiles: errors.length,
+    totalSize: formatSize(totalSize),
+    xmlSize: formatSize(xmlFileSize),
+    totalLines,
+    estimatedTokens: estimatedTokens.toLocaleString(),
+  };
+}
+
+module.exports = { calculateStatistics };

package/tools/flattener/xml.js

@@ -0,0 +1,86 @@
+const fs = require("fs-extra");
+
+function escapeXml(str) {
+  if (typeof str !== "string") {
+    return String(str);
+  }
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/'/g, "&apos;");
+}
+
+function indentFileContent(content) {
+  if (typeof content !== "string") {
+    return String(content);
+  }
+  return content.split("\n").map((line) => `    ${line}`);
+}
+
+function generateXMLOutput(aggregatedContent, outputPath) {
+  const { textFiles } = aggregatedContent;
+  const writeStream = fs.createWriteStream(outputPath, { encoding: "utf8" });
+
+  return new Promise((resolve, reject) => {
+    writeStream.on("error", reject);
+    writeStream.on("finish", resolve);
+
+    writeStream.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+    writeStream.write("<files>\n");
+
+    // Sort files by path for deterministic order
+    const filesSorted = [...textFiles].sort((a, b) =>
+      a.path.localeCompare(b.path)
+    );
+    let index = 0;
+
+    const writeNext = () => {
+      if (index >= filesSorted.length) {
+        writeStream.write("</files>\n");
+        writeStream.end();
+        return;
+      }
+
+      const file = filesSorted[index++];
+      const p = escapeXml(file.path);
+      const content = typeof file.content === "string" ? file.content : "";
+
+      if (content.length === 0) {
+        writeStream.write(`\t<file path='${p}'/>\n`);
+        setTimeout(writeNext, 0);
+        return;
+      }
+
+      const needsCdata = content.includes("<") || content.includes("&") ||
+        content.includes("]]>");
+      if (needsCdata) {
+        // Open tag and CDATA on their own line with tab indent; content lines indented with two tabs
+        writeStream.write(`\t<file path='${p}'><![CDATA[\n`);
+        // Safely split any occurrences of "]]>" inside content, trim trailing newlines, indent each line with two tabs
+        const safe = content.replace(/]]>/g, "]]]]><![CDATA[>");
+        const trimmed = safe.replace(/[\r\n]+$/, "");
+        const indented = trimmed.length > 0
+          ? trimmed.split("\n").map((line) => `\t\t${line}`).join("\n")
+          : "";
+        writeStream.write(indented);
+        // Close CDATA and attach closing tag directly after the last content line
+        writeStream.write("]]></file>\n");
+      } else {
+        // Write opening tag then newline; indent content with two tabs; attach closing tag directly after last content char
+        writeStream.write(`\t<file path='${p}'>\n`);
+        const trimmed = content.replace(/[\r\n]+$/, "");
+        const indented = trimmed.length > 0
+          ? trimmed.split("\n").map((line) => `\t\t${line}`).join("\n")
+          : "";
+        writeStream.write(indented);
+        writeStream.write(`</file>\n`);
+      }
+
+      setTimeout(writeNext, 0);
+    };
+
+    writeNext();
+  });
+}
+
+module.exports = { generateXMLOutput };

package/tools/installer/lib/installer.js

@@ -237,6 +237,10 @@ class Installer {
       // Copy common/ items to .bmad-core
       spinner.text = "Copying common utilities...";
       await this.copyCommonItems(installDir, ".bmad-core", spinner);
+      
+      // Copy documentation files from docs/ to .bmad-core
+      spinner.text = "Copying documentation files...";
+      await this.copyDocsItems(installDir, ".bmad-core", spinner);
 
       // Get list of all files for manifest
       const foundFiles = await resourceLocator.findFiles("**/*", {
@@ -308,6 +312,11 @@ class Installer {
       spinner.text = "Copying common utilities...";
       const commonFiles = await this.copyCommonItems(installDir, ".bmad-core", spinner);
       files.push(...commonFiles);
+      
+      // Copy documentation files from docs/ to .bmad-core
+      spinner.text = "Copying documentation files...";
+      const docFiles = await this.copyDocsItems(installDir, ".bmad-core", spinner);
+      files.push(...docFiles);
     } else if (config.installType === "team") {
       // Team installation
       spinner.text = `Installing ${config.team} team...`;
@@ -353,6 +362,11 @@ class Installer {
       spinner.text = "Copying common utilities...";
       const commonFiles = await this.copyCommonItems(installDir, ".bmad-core", spinner);
       files.push(...commonFiles);
+      
+      // Copy documentation files from docs/ to .bmad-core
+      spinner.text = "Copying documentation files...";
+      const docFiles = await this.copyDocsItems(installDir, ".bmad-core", spinner);
+      files.push(...docFiles);
     } else if (config.installType === "expansion-only") {
       // Expansion-only installation - DO NOT create .bmad-core
       // Only install expansion packs
@@ -896,7 +910,7 @@ class Installer {
     }
 
     // Important notice to read the user guide
-    console.log(chalk.red.bold("\n📖 IMPORTANT: Please read the user guide installed at .bmad-core/user-guide.md"));
+    console.log(chalk.red.bold("\n📖 IMPORTANT: Please read the user guide at docs/user-guide.md (also installed at .bmad-core/user-guide.md)"));
     console.log(chalk.red("This guide contains essential information about the BMad workflow and how to use the agents effectively."));
   }
 
@@ -1557,6 +1571,54 @@ class Installer {
     return copiedFiles;
   }
 
+  async copyDocsItems(installDir, targetSubdir, spinner) {
+    const fs = require('fs').promises;
+    const sourceBase = path.dirname(path.dirname(path.dirname(path.dirname(__filename)))); // Go up to project root
+    const docsPath = path.join(sourceBase, 'docs');
+    const targetPath = path.join(installDir, targetSubdir);
+    const copiedFiles = [];
+    
+    // Specific documentation files to copy
+    const docFiles = [
+      'enhanced-ide-development-workflow.md',
+      'user-guide.md',
+      'working-in-the-brownfield.md'
+    ];
+    
+    // Check if docs/ exists
+    if (!(await fileManager.pathExists(docsPath))) {
+      console.warn('Warning: docs/ folder not found');
+      return copiedFiles;
+    }
+    
+    // Copy specific documentation files from docs/ to target
+    for (const docFile of docFiles) {
+      const sourcePath = path.join(docsPath, docFile);
+      const destPath = path.join(targetPath, docFile);
+      
+      // Check if the source file exists
+      if (await fileManager.pathExists(sourcePath)) {
+        // Read the file content
+        const content = await fs.readFile(sourcePath, 'utf8');
+        
+        // Replace {root} with the target subdirectory
+        const updatedContent = content.replace(/\{root\}/g, targetSubdir);
+        
+        // Ensure directory exists
+        await fileManager.ensureDirectory(path.dirname(destPath));
+        
+        // Write the updated content
+        await fs.writeFile(destPath, updatedContent, 'utf8');
+        copiedFiles.push(path.join(targetSubdir, docFile));
+      }
+    }
+    
+    if (copiedFiles.length > 0) {
+      console.log(chalk.dim(`  Added ${copiedFiles.length} documentation files`));
+    }
+    return copiedFiles;
+  }
+
   async detectExpansionPacks(installDir) {
     const expansionPacks = {};
     const glob = require("glob");

package/tools/installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmad-method",
-  "version": "4.35.2",
+  "version": "4.36.0",
   "description": "BMad Method installer - AI-powered Agile development framework",
   "main": "lib/installer.js",
   "bin": {

package/tools/shared/bannerArt.js

@@ -0,0 +1,105 @@
+// ASCII banner art definitions extracted from banners.js to separate art from logic
+
+const BMAD_TITLE = "BMAD-METHOD";
+const FLATTENER_TITLE = "FLATTENER";
+const INSTALLER_TITLE = "INSTALLER";
+
+// Large ASCII blocks (block-style fonts)
+const BMAD_LARGE = `
+██████╗ ███╗   ███╗ █████╗ ██████╗       ███╗   ███╗███████╗████████╗██╗  ██╗ ██████╗ ██████╗ 
+██╔══██╗████╗ ████║██╔══██╗██╔══██╗      ████╗ ████║██╔════╝╚══██╔══╝██║  ██║██╔═══██╗██╔══██╗
+██████╔╝██╔████╔██║███████║██║  ██║█████╗██╔████╔██║█████╗     ██║   ███████║██║   ██║██║  ██║
+██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║╚════╝██║╚██╔╝██║██╔══╝     ██║   ██╔══██║██║   ██║██║  ██║
+██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝      ██║ ╚═╝ ██║███████╗   ██║   ██║  ██║╚██████╔╝██████╔╝
+╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝       ╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ 
+`;
+
+const FLATTENER_LARGE = `
+███████╗██╗      █████╗ ████████╗████████╗███████╗███╗   ██╗███████╗██████╗ 
+██╔════╝██║     ██╔══██╗╚══██╔══╝╚══██╔══╝██╔════╝████╗  ██║██╔════╝██╔══██╗
+█████╗  ██║     ███████║   ██║      ██║   █████╗  ██╔██╗ ██║█████╗  ██████╔╝
+██╔══╝  ██║     ██╔══██║   ██║      ██║   ██╔══╝  ██║╚██╗██║██╔══╝  ██╔══██╗
+██║     ███████║██║  ██║   ██║      ██║   ███████╗██║ ╚████║███████╗██║  ██║
+╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝
+ `;
+
+const INSTALLER_LARGE = `
+██╗███╗   ██╗███████╗████████╗ █████╗ ██╗     ██╗     ███████╗██████╗ 
+██║████╗  ██║██╔════╝╚══██╔══╝██╔══██╗██║     ██║     ██╔════╝██╔══██╗
+██║██╔██╗ ██║███████╗   ██║   ███████║██║     ██║     █████╗  ██████╔╝
+██║██║╚██╗██║╚════██║   ██║   ██╔══██║██║     ██║     ██╔══╝  ██╔══██╗
+██║██║ ╚████║███████║   ██║   ██║  ██║███████╗███████╗███████╗██║  ██║
+╚═╝╚═╝  ╚═══╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝
+`;
+
+// Curated medium/small/tiny variants (fixed art, no runtime scaling)
+// Medium: bold framed title with heavy fill (high contrast, compact)
+const BMAD_MEDIUM = `
+███╗ █╗    █╗ ██╗ ███╗    █╗    █╗███╗█████╗█╗ █╗ ██╗ ███╗ 
+█╔═█╗██╗  ██║█╔═█╗█╔═█╗   ██╗  ██║█╔═╝╚═█╔═╝█║ █║█╔═█╗█╔═█╗
+███╔╝█╔███╔█║████║█║ █║██╗█╔███╔█║██╗   █║  ████║█║ █║█║ █║
+█╔═█╗█║ █╔╝█║█╔═█║█║ █║╚═╝█║ █╔╝█║█╔╝   █║  █╔═█║█║ █║█║ █║
+███╔╝█║ ╚╝ █║█║ █║███╔╝   █║ ╚╝ █║███╗  █║  █║ █║╚██╔╝███╔╝
+╚══╝ ╚╝    ╚╝╚╝ ╚╝╚══╝    ╚╝    ╚╝╚══╝  ╚╝  ╚╝ ╚╝ ╚═╝ ╚══╝ 
+`;
+
+const FLATTENER_MEDIUM = `
+███╗█╗   ██╗ █████╗█████╗███╗█╗  █╗███╗███╗ 
+█╔═╝█║  █╔═█╗╚═█╔═╝╚═█╔═╝█╔═╝██╗ █║█╔═╝█╔═█╗
+██╗ █║  ████║  █║    █║  ██╗ █╔█╗█║██╗ ███╔╝
+█╔╝ █║  █╔═█║  █║    █║  █╔╝ █║ ██║█╔╝ █╔═█╗
+█║  ███║█║ █║  █║    █║  ███╗█║  █║███╗█║ █║
+╚╝  ╚══╝╚╝ ╚╝  ╚╝    ╚╝  ╚══╝╚╝  ╚╝╚══╝╚╝ ╚╝
+ `;
+
+const INSTALLER_MEDIUM = `
+█╗█╗  █╗████╗█████╗ ██╗ █╗  █╗  ███╗███╗ 
+█║██╗ █║█╔══╝╚═█╔═╝█╔═█╗█║  █║  █╔═╝█╔═█╗
+█║█╔█╗█║████╗  █║  ████║█║  █║  ██╗ ███╔╝
+█║█║ ██║╚══█║  █║  █╔═█║█║  █║  █╔╝ █╔═█╗
+█║█║  █║████║  █║  █║ █║███╗███╗███╗█║ █║
+╚╝╚╝  ╚╝╚═══╝  ╚╝  ╚╝ ╚╝╚══╝╚══╝╚══╝╚╝ ╚╝
+`;
+
+// Small: rounded box with bold rule
+// Width: 30 columns total (28 inner)
+const BMAD_SMALL = `
+╭──────────────────────────╮
+│        BMAD-METHOD       │
+╰──────────────────────────╯
+`;
+
+const FLATTENER_SMALL = `
+╭──────────────────────────╮
+│         FLATTENER        │
+╰──────────────────────────╯
+`;
+
+const INSTALLER_SMALL = `
+ ╭──────────────────────────╮
+ │         INSTALLER        │
+ ╰──────────────────────────╯
+ `;
+
+// Tiny (compact brackets)
+const BMAD_TINY = `[ BMAD-METHOD ]`;
+const FLATTENER_TINY = `[ FLATTENER ]`;
+const INSTALLER_TINY = `[ INSTALLER ]`;
+
+module.exports = {
+  BMAD_TITLE,
+  FLATTENER_TITLE,
+  INSTALLER_TITLE,
+  BMAD_LARGE,
+  FLATTENER_LARGE,
+  INSTALLER_LARGE,
+  BMAD_MEDIUM,
+  FLATTENER_MEDIUM,
+  INSTALLER_MEDIUM,
+  BMAD_SMALL,
+  FLATTENER_SMALL,
+  INSTALLER_SMALL,
+  BMAD_TINY,
+  FLATTENER_TINY,
+  INSTALLER_TINY,
+};