bmad-method 4.37.0-beta.4 → 4.37.0-beta.6

package/tools/flattener/ignoreRules.js

@@ -0,0 +1,176 @@
+const fs = require("fs-extra");
+const path = require("node:path");
+const ignore = require("ignore");
+
+// Central default ignore patterns for discovery and filtering.
+// These complement .gitignore and are applied regardless of VCS presence.
+const DEFAULT_PATTERNS = [
+  // Project/VCS
+  "**/.bmad-core/**",
+  "**/.git/**",
+  "**/.svn/**",
+  "**/.hg/**",
+  "**/.bzr/**",
+  // Package/build outputs
+  "**/node_modules/**",
+  "**/bower_components/**",
+  "**/vendor/**",
+  "**/packages/**",
+  "**/build/**",
+  "**/dist/**",
+  "**/out/**",
+  "**/target/**",
+  "**/bin/**",
+  "**/obj/**",
+  "**/release/**",
+  "**/debug/**",
+  // Environments
+  "**/.venv/**",
+  "**/venv/**",
+  "**/.virtualenv/**",
+  "**/virtualenv/**",
+  "**/env/**",
+  // Logs & coverage
+  "**/*.log",
+  "**/npm-debug.log*",
+  "**/yarn-debug.log*",
+  "**/yarn-error.log*",
+  "**/lerna-debug.log*",
+  "**/coverage/**",
+  "**/.nyc_output/**",
+  "**/.coverage/**",
+  "**/test-results/**",
+  // Caches & temp
+  "**/.cache/**",
+  "**/.tmp/**",
+  "**/.temp/**",
+  "**/tmp/**",
+  "**/temp/**",
+  "**/.sass-cache/**",
+  // IDE/editor
+  "**/.vscode/**",
+  "**/.idea/**",
+  "**/*.swp",
+  "**/*.swo",
+  "**/*~",
+  "**/.project",
+  "**/.classpath",
+  "**/.settings/**",
+  "**/*.sublime-project",
+  "**/*.sublime-workspace",
+  // Lockfiles
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/composer.lock",
+  "**/Pipfile.lock",
+  // Python/Java/compiled artifacts
+  "**/*.pyc",
+  "**/*.pyo",
+  "**/*.pyd",
+  "**/__pycache__/**",
+  "**/*.class",
+  "**/*.jar",
+  "**/*.war",
+  "**/*.ear",
+  "**/*.o",
+  "**/*.so",
+  "**/*.dll",
+  "**/*.exe",
+  // System junk
+  "**/lib64/**",
+  "**/.venv/lib64/**",
+  "**/venv/lib64/**",
+  "**/_site/**",
+  "**/.jekyll-cache/**",
+  "**/.jekyll-metadata",
+  "**/.DS_Store",
+  "**/.DS_Store?",
+  "**/._*",
+  "**/.Spotlight-V100/**",
+  "**/.Trashes/**",
+  "**/ehthumbs.db",
+  "**/Thumbs.db",
+  "**/desktop.ini",
+  // XML outputs
+  "**/flattened-codebase.xml",
+  "**/repomix-output.xml",
+  // Images, media, fonts, archives, docs, dylibs
+  "**/*.jpg",
+  "**/*.jpeg",
+  "**/*.png",
+  "**/*.gif",
+  "**/*.bmp",
+  "**/*.ico",
+  "**/*.svg",
+  "**/*.pdf",
+  "**/*.doc",
+  "**/*.docx",
+  "**/*.xls",
+  "**/*.xlsx",
+  "**/*.ppt",
+  "**/*.pptx",
+  "**/*.zip",
+  "**/*.tar",
+  "**/*.gz",
+  "**/*.rar",
+  "**/*.7z",
+  "**/*.dylib",
+  "**/*.mp3",
+  "**/*.mp4",
+  "**/*.avi",
+  "**/*.mov",
+  "**/*.wav",
+  "**/*.ttf",
+  "**/*.otf",
+  "**/*.woff",
+  "**/*.woff2",
+  // Env files
+  "**/.env",
+  "**/.env.*",
+  "**/*.env",
+  // Misc
+  "**/junit.xml",
+];
+
+async function readIgnoreFile(filePath) {
+  try {
+    if (!await fs.pathExists(filePath)) return [];
+    const content = await fs.readFile(filePath, "utf8");
+    return content
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith("#"));
+  } catch (err) {
+    return [];
+  }
+}
+
+// Backward compatible export matching previous signature
+async function parseGitignore(gitignorePath) {
+  return readIgnoreFile(gitignorePath);
+}
+
+async function loadIgnore(rootDir, extraPatterns = []) {
+  const ig = ignore();
+  const gitignorePath = path.join(rootDir, ".gitignore");
+  const patterns = [
+    ...await readIgnoreFile(gitignorePath),
+    ...DEFAULT_PATTERNS,
+    ...extraPatterns,
+  ];
+  // De-duplicate
+  const unique = Array.from(new Set(patterns.map((p) => String(p))));
+  ig.add(unique);
+
+  // Include-only filter: return true if path should be included
+  const filter = (relativePath) => !ig.ignores(relativePath.replace(/\\/g, "/"));
+
+  return { ig, filter, patterns: unique };
+}
+
+module.exports = {
+  DEFAULT_PATTERNS,
+  parseGitignore,
+  loadIgnore,
+};

package/tools/flattener/main.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+const fs = require("fs-extra");
+const path = require("node:path");
+const process = require("node:process");
+
+// Modularized components
+const { findProjectRoot } = require("./projectRoot.js");
+const { promptYesNo, promptPath } = require("./prompts.js");
+const {
+  discoverFiles,
+  filterFiles,
+  aggregateFileContents,
+} = require("./files.js");
+const { generateXMLOutput } = require("./xml.js");
+const { calculateStatistics } = require("./stats.js");
+
+/**
+ * Recursively discover all files in a directory
+ * @param {string} rootDir - The root directory to scan
+ * @returns {Promise<string[]>} Array of file paths
+ */
+
+/**
+ * Parse .gitignore file and return ignore patterns
+ * @param {string} gitignorePath - Path to .gitignore file
+ * @returns {Promise<string[]>} Array of ignore patterns
+ */
+
+/**
+ * Check if a file is binary using file command and heuristics
+ * @param {string} filePath - Path to the file
+ * @returns {Promise<boolean>} True if file is binary
+ */
+
+/**
+ * Read and aggregate content from text files
+ * @param {string[]} files - Array of file paths
+ * @param {string} rootDir - The root directory
+ * @param {Object} spinner - Optional spinner instance for progress display
+ * @returns {Promise<Object>} Object containing file contents and metadata
+ */
+
+/**
+ * Generate XML output with aggregated file contents using streaming
+ * @param {Object} aggregatedContent - The aggregated content object
+ * @param {string} outputPath - The output file path
+ * @returns {Promise<void>} Promise that resolves when writing is complete
+ */
+
+/**
+ * Calculate statistics for the processed files
+ * @param {Object} aggregatedContent - The aggregated content object
+ * @param {number} xmlFileSize - The size of the generated XML file in bytes
+ * @returns {Object} Statistics object
+ */
+
+/**
+ * Filter files based on .gitignore patterns
+ * @param {string[]} files - Array of file paths
+ * @param {string} rootDir - The root directory
+ * @returns {Promise<string[]>} Filtered array of file paths
+ */
+
+/**
+ * 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
+ */
+
+const program = new Command();
+
+program
+  .name("bmad-flatten")
+  .description("BMad-Method codebase flattener tool")
+  .version("1.0.0")
+  .option("-i, --input <path>", "Input directory to flatten", process.cwd())
+  .option("-o, --output <path>", "Output file path", "flattened-codebase.xml")
+  .action(async (options) => {
+    let inputDir = path.resolve(options.input);
+    let outputPath = path.resolve(options.output);
+
+    // Detect if user explicitly provided -i/--input or -o/--output
+    const argv = process.argv.slice(2);
+    const userSpecifiedInput = argv.some((a) =>
+      a === "-i" || a === "--input" || a.startsWith("--input=")
+    );
+    const userSpecifiedOutput = argv.some((a) =>
+      a === "-o" || a === "--output" || a.startsWith("--output=")
+    );
+    const noPathArgs = !userSpecifiedInput && !userSpecifiedOutput;
+
+    if (noPathArgs) {
+      const detectedRoot = await findProjectRoot(process.cwd());
+      const suggestedOutput = detectedRoot
+        ? path.join(detectedRoot, "flattened-codebase.xml")
+        : path.resolve("flattened-codebase.xml");
+
+      if (detectedRoot) {
+        const useDefaults = await promptYesNo(
+          `Detected project root at "${detectedRoot}". Use it as input and write output to "${suggestedOutput}"?`,
+          true,
+        );
+        if (useDefaults) {
+          inputDir = detectedRoot;
+          outputPath = suggestedOutput;
+        } else {
+          inputDir = await promptPath(
+            "Enter input directory path",
+            process.cwd(),
+          );
+          outputPath = await promptPath(
+            "Enter output file path",
+            path.join(inputDir, "flattened-codebase.xml"),
+          );
+        }
+      } else {
+        console.log("Could not auto-detect a project root.");
+        inputDir = await promptPath(
+          "Enter input directory path",
+          process.cwd(),
+        );
+        outputPath = await promptPath(
+          "Enter output file path",
+          path.join(inputDir, "flattened-codebase.xml"),
+        );
+      }
+    } else {
+      console.error(
+        "Could not auto-detect a project root and no arguments were provided. Please specify -i/--input and -o/--output.",
+      );
+      process.exit(1);
+    }
+
+    // Ensure output directory exists
+    await fs.ensureDir(path.dirname(outputPath));
+
+    console.log(`Flattening codebase from: ${inputDir}`);
+    console.log(`Output file: ${outputPath}`);
+
+    try {
+      // Verify input directory exists
+      if (!await fs.pathExists(inputDir)) {
+        console.error(`❌ Error: Input directory does not exist: ${inputDir}`);
+        process.exit(1);
+      }
+
+      // Import ora dynamically
+      const { default: ora } = await import("ora");
+
+      // Start file discovery with spinner
+      const discoverySpinner = ora("🔍 Discovering files...").start();
+      const files = await discoverFiles(inputDir);
+      const filteredFiles = await filterFiles(files, inputDir);
+      discoverySpinner.succeed(
+        `📁 Found ${filteredFiles.length} files to include`,
+      );
+
+      // Process files with progress tracking
+      console.log("Reading file contents");
+      const processingSpinner = ora("📄 Processing files...").start();
+      const aggregatedContent = await aggregateFileContents(
+        filteredFiles,
+        inputDir,
+        processingSpinner,
+      );
+      processingSpinner.succeed(
+        `✅ Processed ${aggregatedContent.processedFiles}/${filteredFiles.length} files`,
+      );
+      if (aggregatedContent.errors.length > 0) {
+        console.log(`Errors: ${aggregatedContent.errors.length}`);
+      }
+      console.log(`Text files: ${aggregatedContent.textFiles.length}`);
+      if (aggregatedContent.binaryFiles.length > 0) {
+        console.log(`Binary files: ${aggregatedContent.binaryFiles.length}`);
+      }
+
+      // Generate XML output using streaming
+      const xmlSpinner = ora("🔧 Generating XML output...").start();
+      await generateXMLOutput(aggregatedContent, outputPath);
+      xmlSpinner.succeed("📝 XML generation completed");
+
+      // Calculate and display statistics
+      const outputStats = await fs.stat(outputPath);
+      const stats = calculateStatistics(aggregatedContent, outputStats.size);
+
+      // Display completion summary
+      console.log("\n📊 Completion Summary:");
+      console.log(
+        `✅ Successfully processed ${filteredFiles.length} files into ${
+          path.basename(outputPath)
+        }`,
+      );
+      console.log(`📁 Output file: ${outputPath}`);
+      console.log(`📏 Total source size: ${stats.totalSize}`);
+      console.log(`📄 Generated XML size: ${stats.xmlSize}`);
+      console.log(
+        `📝 Total lines of code: ${stats.totalLines.toLocaleString()}`,
+      );
+      console.log(`🔢 Estimated tokens: ${stats.estimatedTokens}`);
+      console.log(
+        `📊 File breakdown: ${stats.textFiles} text, ${stats.binaryFiles} binary, ${stats.errorFiles} errors`,
+      );
+    } catch (error) {
+      console.error("❌ Critical error:", error.message);
+      console.error("An unexpected error occurred.");
+      process.exit(1);
+    }
+  });
+
+if (require.main === module) {
+  program.parse();
+}
+
+module.exports = program;

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/README.md

@@ -0,0 +1,8 @@
+# BMad Method Installer
+
+## Usage
+
+```bash
+# Interactive installation
+npx bmad-method install
+```

package/tools/installer/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "bmad-method",
+  "version": "4.37.0-beta.6",
+  "description": "BMad Method installer - AI-powered Agile development framework",
+  "main": "lib/installer.js",
+  "bin": {
+    "bmad": "./bin/bmad.js",
+    "bmad-method": "./bin/bmad.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "bmad",
+    "agile",
+    "ai",
+    "development",
+    "framework",
+    "installer",
+    "agents"
+  ],
+  "author": "BMad Team",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^14.0.0",
+    "fs-extra": "^11.3.0",
+    "inquirer": "^8.2.6",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1",
+    "semver": "^7.6.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bmad-team/bmad-method.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bmad-team/bmad-method/issues"
+  },
+  "homepage": "https://github.com/bmad-team/bmad-method#readme"
+}