bmad-method 4.35.3 → 4.36.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmad-method",
-  "version": "4.35.3",
+  "version": "4.36.1",
   "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,
+};