bmad-method 6.0.0-alpha.9 → 6.0.1

package/tools/flattener/test-matrix.js

@@ -1,409 +0,0 @@
-/* deno-lint-ignore-file */
-/*
- Automatic test matrix for project root detection.
- Creates temporary fixtures for various ecosystems and validates findProjectRoot().
- No external options or flags required. Safe to run multiple times.
-*/
-
-const os = require('node:os');
-const path = require('node:path');
-const fs = require('fs-extra');
-const { promisify } = require('node:util');
-const { execFile } = require('node:child_process');
-const process = require('node:process');
-const execFileAsync = promisify(execFile);
-
-const { findProjectRoot } = require('./projectRoot.js');
-
-async function cmdAvailable(cmd) {
-  try {
-    await execFileAsync(cmd, ['--version'], { timeout: 500, windowsHide: true });
-    return true;
-  } catch {
-    return false;
-  }
-
-  async function testSvnMarker() {
-    const root = await mkTmpDir('svn');
-    const nested = path.join(root, 'proj', 'code');
-    await fs.ensureDir(nested);
-    await fs.ensureDir(path.join(root, '.svn'));
-    const found = await findProjectRoot(nested);
-    assertEqual(found, root, '.svn marker should be detected');
-    return { name: 'svn-marker', ok: true };
-  }
-
-  async function testSymlinkStart() {
-    const root = await mkTmpDir('symlink-start');
-    const nested = path.join(root, 'a', 'b');
-    await fs.ensureDir(nested);
-    await fs.writeFile(path.join(root, '.project-root'), '\n');
-    const tmp = await mkTmpDir('symlink-tmp');
-    const link = path.join(tmp, 'link-to-b');
-    try {
-      await fs.symlink(nested, link);
-    } catch {
-      // symlink may not be permitted on some systems; skip
-      return { name: 'symlink-start', ok: true, skipped: true };
-    }
-    const found = await findProjectRoot(link);
-    assertEqual(found, root, 'should resolve symlinked start to real root');
-    return { name: 'symlink-start', ok: true };
-  }
-
-  async function testSubmoduleLikeInnerGitFile() {
-    const root = await mkTmpDir('submodule-like');
-    const mid = path.join(root, 'mid');
-    const leaf = path.join(mid, 'leaf');
-    await fs.ensureDir(leaf);
-    // outer repo
-    await fs.ensureDir(path.join(root, '.git'));
-    // inner submodule-like .git file
-    await fs.writeFile(path.join(mid, '.git'), 'gitdir: ../.git/modules/mid\n');
-    const found = await findProjectRoot(leaf);
-    assertEqual(found, root, 'outermost .git should win on tie weight');
-    return { name: 'submodule-like-gitfile', ok: true };
-  }
-}
-
-async function mkTmpDir(name) {
-  const base = await fs.realpath(os.tmpdir());
-  const dir = await fs.mkdtemp(path.join(base, `flattener-${name}-`));
-  return dir;
-}
-
-function assertEqual(actual, expected, msg) {
-  if (actual !== expected) {
-    throw new Error(`${msg}: expected="${expected}" actual="${actual}"`);
-  }
-}
-
-async function testSentinel() {
-  const root = await mkTmpDir('sentinel');
-  const nested = path.join(root, 'a', 'b', 'c');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, '.project-root'), '\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'sentinel .project-root should win');
-  return { name: 'sentinel', ok: true };
-}
-
-async function testOtherSentinels() {
-  const root = await mkTmpDir('other-sentinels');
-  const nested = path.join(root, 'x', 'y');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, '.workspace-root'), '\n');
-  const found1 = await findProjectRoot(nested);
-  assertEqual(found1, root, 'sentinel .workspace-root should win');
-
-  await fs.remove(path.join(root, '.workspace-root'));
-  await fs.writeFile(path.join(root, '.repo-root'), '\n');
-  const found2 = await findProjectRoot(nested);
-  assertEqual(found2, root, 'sentinel .repo-root should win');
-  return { name: 'other-sentinels', ok: true };
-}
-
-async function testGitCliAndMarker() {
-  const hasGit = await cmdAvailable('git');
-  if (!hasGit) return { name: 'git-cli', ok: true, skipped: true };
-
-  const root = await mkTmpDir('git');
-  const nested = path.join(root, 'pkg', 'src');
-  await fs.ensureDir(nested);
-  await execFileAsync('git', ['init'], { cwd: root, timeout: 2000 });
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'git toplevel should be detected');
-  return { name: 'git-cli', ok: true };
-}
-
-async function testHgMarkerOrCli() {
-  // Prefer simple marker test to avoid requiring Mercurial install
-  const root = await mkTmpDir('hg');
-  const nested = path.join(root, 'lib');
-  await fs.ensureDir(nested);
-  await fs.ensureDir(path.join(root, '.hg'));
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, '.hg marker should be detected');
-  return { name: 'hg-marker', ok: true };
-}
-
-async function testWorkspacePnpm() {
-  const root = await mkTmpDir('pnpm-workspace');
-  const pkgA = path.join(root, 'packages', 'a');
-  await fs.ensureDir(pkgA);
-  await fs.writeFile(path.join(root, 'pnpm-workspace.yaml'), 'packages:\n  - packages/*\n');
-  const found = await findProjectRoot(pkgA);
-  await assertEqual(found, root, 'pnpm-workspace.yaml should be detected');
-  return { name: 'pnpm-workspace', ok: true };
-}
-
-async function testPackageJsonWorkspaces() {
-  const root = await mkTmpDir('package-workspaces');
-  const pkgA = path.join(root, 'packages', 'a');
-  await fs.ensureDir(pkgA);
-  await fs.writeJson(path.join(root, 'package.json'), { private: true, workspaces: ['packages/*'] }, { spaces: 2 });
-  const found = await findProjectRoot(pkgA);
-  await assertEqual(found, root, 'package.json workspaces should be detected');
-  return { name: 'package.json-workspaces', ok: true };
-}
-
-async function testLockfiles() {
-  const root = await mkTmpDir('lockfiles');
-  const nested = path.join(root, 'src');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'yarn.lock'), '\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'yarn.lock should be detected');
-  return { name: 'lockfiles', ok: true };
-}
-
-async function testLanguageConfigs() {
-  const root = await mkTmpDir('lang-configs');
-  const nested = path.join(root, 'x', 'y');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'pyproject.toml'), "[tool.poetry]\nname='tmp'\n");
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'pyproject.toml should be detected');
-  return { name: 'language-configs', ok: true };
-}
-
-async function testPreferOuterOnTie() {
-  const root = await mkTmpDir('tie');
-  const mid = path.join(root, 'mid');
-  const leaf = path.join(mid, 'leaf');
-  await fs.ensureDir(leaf);
-  // same weight marker at two levels
-  await fs.writeFile(path.join(root, 'requirements.txt'), '\n');
-  await fs.writeFile(path.join(mid, 'requirements.txt'), '\n');
-  const found = await findProjectRoot(leaf);
-  await assertEqual(found, root, 'outermost directory should win on equal weight');
-  return { name: 'prefer-outermost-tie', ok: true };
-}
-
-// Additional coverage: Bazel, Nx/Turbo/Rush, Go workspaces, Deno, Java/Scala, PHP, Rust, Nix, Changesets, env markers,
-// and priority interaction between package.json and lockfiles.
-
-async function testBazelWorkspace() {
-  const root = await mkTmpDir('bazel');
-  const nested = path.join(root, 'apps', 'svc');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'WORKSPACE'), 'workspace(name="tmp")\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'Bazel WORKSPACE should be detected');
-  return { name: 'bazel-workspace', ok: true };
-}
-
-async function testNx() {
-  const root = await mkTmpDir('nx');
-  const nested = path.join(root, 'apps', 'web');
-  await fs.ensureDir(nested);
-  await fs.writeJson(path.join(root, 'nx.json'), { npmScope: 'tmp' }, { spaces: 2 });
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'nx.json should be detected');
-  return { name: 'nx', ok: true };
-}
-
-async function testTurbo() {
-  const root = await mkTmpDir('turbo');
-  const nested = path.join(root, 'packages', 'x');
-  await fs.ensureDir(nested);
-  await fs.writeJson(path.join(root, 'turbo.json'), { pipeline: {} }, { spaces: 2 });
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'turbo.json should be detected');
-  return { name: 'turbo', ok: true };
-}
-
-async function testRush() {
-  const root = await mkTmpDir('rush');
-  const nested = path.join(root, 'apps', 'a');
-  await fs.ensureDir(nested);
-  await fs.writeJson(path.join(root, 'rush.json'), { projectFolderMinDepth: 1 }, { spaces: 2 });
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'rush.json should be detected');
-  return { name: 'rush', ok: true };
-}
-
-async function testGoWorkAndMod() {
-  const root = await mkTmpDir('gowork');
-  const mod = path.join(root, 'modA');
-  const nested = path.join(mod, 'pkg');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'go.work'), 'go 1.22\nuse ./modA\n');
-  await fs.writeFile(path.join(mod, 'go.mod'), 'module example.com/a\ngo 1.22\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'go.work should define the workspace root');
-  return { name: 'go-work', ok: true };
-}
-
-async function testDenoJson() {
-  const root = await mkTmpDir('deno');
-  const nested = path.join(root, 'src');
-  await fs.ensureDir(nested);
-  await fs.writeJson(path.join(root, 'deno.json'), { tasks: {} }, { spaces: 2 });
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'deno.json should be detected');
-  return { name: 'deno-json', ok: true };
-}
-
-async function testGradleSettings() {
-  const root = await mkTmpDir('gradle');
-  const nested = path.join(root, 'app');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'settings.gradle'), "rootProject.name='tmp'\n");
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'settings.gradle should be detected');
-  return { name: 'gradle-settings', ok: true };
-}
-
-async function testMavenPom() {
-  const root = await mkTmpDir('maven');
-  const nested = path.join(root, 'module');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'pom.xml'), '<project></project>\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'pom.xml should be detected');
-  return { name: 'maven-pom', ok: true };
-}
-
-async function testSbtBuild() {
-  const root = await mkTmpDir('sbt');
-  const nested = path.join(root, 'sub');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'build.sbt'), 'name := "tmp"\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'build.sbt should be detected');
-  return { name: 'sbt-build', ok: true };
-}
-
-async function testComposer() {
-  const root = await mkTmpDir('composer');
-  const nested = path.join(root, 'src');
-  await fs.ensureDir(nested);
-  await fs.writeJson(path.join(root, 'composer.json'), { name: 'tmp/pkg' }, { spaces: 2 });
-  await fs.writeFile(path.join(root, 'composer.lock'), '{}\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'composer.{json,lock} should be detected');
-  return { name: 'composer', ok: true };
-}
-
-async function testCargo() {
-  const root = await mkTmpDir('cargo');
-  const nested = path.join(root, 'src');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'Cargo.toml'), "[package]\nname='tmp'\nversion='0.0.0'\n");
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'Cargo.toml should be detected');
-  return { name: 'cargo', ok: true };
-}
-
-async function testNixFlake() {
-  const root = await mkTmpDir('nix');
-  const nested = path.join(root, 'work');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'flake.nix'), '{ }\n');
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, 'flake.nix should be detected');
-  return { name: 'nix-flake', ok: true };
-}
-
-async function testChangesetConfig() {
-  const root = await mkTmpDir('changeset');
-  const nested = path.join(root, 'pkg');
-  await fs.ensureDir(nested);
-  await fs.ensureDir(path.join(root, '.changeset'));
-  await fs.writeJson(
-    path.join(root, '.changeset', 'config.json'),
-    { $schema: 'https://unpkg.com/@changesets/config@2.3.1/schema.json' },
-    { spaces: 2 },
-  );
-  const found = await findProjectRoot(nested);
-  await assertEqual(found, root, '.changeset/config.json should be detected');
-  return { name: 'changesets', ok: true };
-}
-
-async function testEnvCustomMarker() {
-  const root = await mkTmpDir('env-marker');
-  const nested = path.join(root, 'dir');
-  await fs.ensureDir(nested);
-  await fs.writeFile(path.join(root, 'MY_ROOT'), '\n');
-  const prev = process.env.PROJECT_ROOT_MARKERS;
-  process.env.PROJECT_ROOT_MARKERS = 'MY_ROOT';
-  try {
-    const found = await findProjectRoot(nested);
-    await assertEqual(found, root, 'custom env marker should be honored');
-  } finally {
-    if (prev === undefined) delete process.env.PROJECT_ROOT_MARKERS;
-    else process.env.PROJECT_ROOT_MARKERS = prev;
-  }
-  return { name: 'env-custom-marker', ok: true };
-}
-
-async function testPackageLowPriorityVsLock() {
-  const root = await mkTmpDir('pkg-vs-lock');
-  const nested = path.join(root, 'nested');
-  await fs.ensureDir(path.join(nested, 'deep'));
-  await fs.writeJson(path.join(nested, 'package.json'), { name: 'nested' }, { spaces: 2 });
-  await fs.writeFile(path.join(root, 'yarn.lock'), '\n');
-  const found = await findProjectRoot(path.join(nested, 'deep'));
-  await assertEqual(found, root, 'lockfile at root should outrank nested package.json');
-  return { name: 'package-vs-lock-priority', ok: true };
-}
-
-async function run() {
-  const tests = [
-    testSentinel,
-    testOtherSentinels,
-    testGitCliAndMarker,
-    testHgMarkerOrCli,
-    testWorkspacePnpm,
-    testPackageJsonWorkspaces,
-    testLockfiles,
-    testLanguageConfigs,
-    testPreferOuterOnTie,
-    testBazelWorkspace,
-    testNx,
-    testTurbo,
-    testRush,
-    testGoWorkAndMod,
-    testDenoJson,
-    testGradleSettings,
-    testMavenPom,
-    testSbtBuild,
-    testComposer,
-    testCargo,
-    testNixFlake,
-    testChangesetConfig,
-    testEnvCustomMarker,
-    testPackageLowPriorityVsLock,
-    testSvnMarker,
-    testSymlinkStart,
-    testSubmoduleLikeInnerGitFile,
-  ];
-
-  const results = [];
-  for (const t of tests) {
-    try {
-      const r = await t();
-      results.push({ ...r, ok: true });
-      console.log(`✔ ${r.name}${r.skipped ? ' (skipped)' : ''}`);
-    } catch (error) {
-      console.error(`✖ ${t.name}:`, error && error.message ? error.message : error);
-      results.push({ name: t.name, ok: false, error: String(error) });
-    }
-  }
-
-  const failed = results.filter((r) => !r.ok);
-  console.log('\nSummary:');
-  for (const r of results) {
-    console.log(`- ${r.name}: ${r.ok ? 'ok' : 'FAIL'}${r.skipped ? ' (skipped)' : ''}`);
-  }
-
-  if (failed.length > 0) {
-    process.exitCode = 1;
-  }
-}
-
-run().catch((error) => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});

package/tools/flattener/xml.js

@@ -1,88 +0,0 @@
-const fs = require('fs-extra');
-
-function escapeXml(string_) {
-  if (typeof string_ !== 'string') {
-    return String(string_);
-  }
-  return string_.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll("'", '&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.replaceAll(']]>', ']]]]><![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/validate-bundles.js

@@ -1,87 +0,0 @@
-const fs = require('fs-extra');
-const path = require('node:path');
-const xml2js = require('xml2js');
-const chalk = require('chalk');
-const glob = require('glob');
-
-async function validateXmlFile(filePath) {
-  try {
-    const content = await fs.readFile(filePath, 'utf8');
-    await xml2js.parseStringPromise(content, {
-      strict: true,
-      explicitArray: false,
-    });
-    return { valid: true };
-  } catch (error) {
-    return { valid: false, error: error.message };
-  }
-}
-
-async function validateAllBundles() {
-  console.log(chalk.cyan.bold('\n═══════════════════════════════════════════════'));
-  console.log(chalk.cyan.bold('        VALIDATING WEB BUNDLE XML FILES'));
-  console.log(chalk.cyan.bold('═══════════════════════════════════════════════\n'));
-
-  const bundlesDir = path.join(__dirname, '..', 'web-bundles');
-
-  // Find all XML files in web-bundles
-  const pattern = path.join(bundlesDir, '**/*.xml');
-  const files = glob.sync(pattern);
-
-  if (files.length === 0) {
-    console.log(chalk.yellow('No XML files found in web-bundles directory'));
-    return;
-  }
-
-  console.log(`Found ${chalk.bold(files.length)} XML files to validate\n`);
-
-  let validCount = 0;
-  let invalidCount = 0;
-  const invalidFiles = [];
-
-  for (const file of files) {
-    const relativePath = path.relative(bundlesDir, file);
-    const result = await validateXmlFile(file);
-
-    if (result.valid) {
-      console.log(`${chalk.green('✓')} ${relativePath}`);
-      validCount++;
-    } else {
-      console.log(`${chalk.red('✗')} ${relativePath}`);
-      console.log(`  ${chalk.red('→')} ${result.error}`);
-      invalidCount++;
-      invalidFiles.push({ path: relativePath, error: result.error });
-    }
-  }
-
-  // Summary
-  console.log(chalk.cyan.bold('\n═══════════════════════════════════════════════'));
-  console.log(chalk.cyan.bold('                 SUMMARY'));
-  console.log(chalk.cyan.bold('═══════════════════════════════════════════════\n'));
-
-  console.log(`  Total files checked: ${chalk.bold(files.length)}`);
-  console.log(`  Valid XML files:     ${chalk.green(validCount)}`);
-  console.log(`  Invalid XML files:   ${invalidCount > 0 ? chalk.red(invalidCount) : chalk.green(invalidCount)}`);
-
-  if (invalidFiles.length > 0) {
-    console.log(chalk.red.bold('\n  Invalid Files:'));
-    for (const { path, error } of invalidFiles) {
-      console.log(`    ${chalk.red('•')} ${path}`);
-      if (error.length > 100) {
-        console.log(`      ${error.slice(0, 100)}...`);
-      } else {
-        console.log(`      ${error}`);
-      }
-    }
-  }
-
-  console.log(chalk.cyan.bold('\n═══════════════════════════════════════════════\n'));
-
-  process.exit(invalidCount > 0 ? 1 : 0);
-}
-
-// Run validation
-validateAllBundles().catch((error) => {
-  console.error(chalk.red('Error running validation:'), error);
-  process.exit(1);
-});

package/v6-open-items.md

@@ -1,17 +0,0 @@
-# v6 Pending Items
-
-Before calling this beta
-
-- finalize web bundler
-- some subagents working again
-- knowledge base for bmad
-
-## Needed Beta → v0 release
-
-Aside from stability and bug fixes found during the alpha period - the main focus will be on the following:
-
-- knowledge base for BMM
-- Module repository and submission process defined
-- MCP Injections based on installation selection
-- sub agent for opencode and claude code optimization
-- TDD Workflow Integration