ma-agents 2.22.2 → 3.0.1

package/lib/bmad-cache/bmb/skills/bmad-builder-setup/scripts/merge-help-csv.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.9"
+# dependencies = []
+# ///
+"""Merge module help entries into shared _bmad/module-help.csv.
+
+Reads a source CSV with module help entries and merges them into a target CSV.
+Uses an anti-zombie pattern: all existing rows matching the source module code
+are removed before appending fresh rows.
+
+Legacy cleanup: when --legacy-dir and --module-code are provided, deletes old
+per-module module-help.csv files from {legacy-dir}/{module-code}/ and
+{legacy-dir}/core/. Only the current module and core are touched.
+
+Exit codes: 0=success, 1=validation error, 2=runtime error
+"""
+
+import argparse
+import csv
+import json
+import sys
+from io import StringIO
+from pathlib import Path
+
+# CSV header for module-help.csv
+HEADER = [
+    "module",
+    "agent-name",
+    "skill-name",
+    "display-name",
+    "menu-code",
+    "capability",
+    "args",
+    "description",
+    "phase",
+    "after",
+    "before",
+    "required",
+    "output-location",
+    "outputs",
+    "",  # trailing empty column from trailing comma
+]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Merge module help entries into shared _bmad/module-help.csv with anti-zombie pattern."
+    )
+    parser.add_argument(
+        "--target",
+        required=True,
+        help="Path to the target _bmad/module-help.csv file",
+    )
+    parser.add_argument(
+        "--source",
+        required=True,
+        help="Path to the source module-help.csv with entries to merge",
+    )
+    parser.add_argument(
+        "--legacy-dir",
+        help="Path to _bmad/ directory to check for legacy per-module CSV files.",
+    )
+    parser.add_argument(
+        "--module-code",
+        help="Module code (required with --legacy-dir for scoping cleanup).",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print detailed progress to stderr",
+    )
+    return parser.parse_args()
+
+
+def read_csv_rows(path: str) -> tuple[list[str], list[list[str]]]:
+    """Read CSV file returning (header, data_rows).
+
+    Returns empty header and rows if file doesn't exist.
+    """
+    file_path = Path(path)
+    if not file_path.exists():
+        return [], []
+
+    with open(file_path, "r", encoding="utf-8", newline="") as f:
+        content = f.read()
+
+    reader = csv.reader(StringIO(content))
+    rows = list(reader)
+
+    if not rows:
+        return [], []
+
+    return rows[0], rows[1:]
+
+
+def extract_module_codes(rows: list[list[str]]) -> set[str]:
+    """Extract unique module codes from data rows."""
+    codes = set()
+    for row in rows:
+        if row and row[0].strip():
+            codes.add(row[0].strip())
+    return codes
+
+
+def filter_rows(rows: list[list[str]], module_code: str) -> list[list[str]]:
+    """Remove all rows matching the given module code."""
+    return [row for row in rows if not row or row[0].strip() != module_code]
+
+
+def write_csv(path: str, header: list[str], rows: list[list[str]], verbose: bool = False) -> None:
+    """Write header + rows to CSV file, creating parent dirs as needed."""
+    file_path = Path(path)
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if verbose:
+        print(f"Writing {len(rows)} data rows to {path}", file=sys.stderr)
+
+    with open(file_path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(header)
+        for row in rows:
+            writer.writerow(row)
+
+
+def cleanup_legacy_csvs(
+    legacy_dir: str, module_code: str, verbose: bool = False
+) -> list:
+    """Delete legacy per-module module-help.csv files for this module and core only.
+
+    Returns list of deleted file paths.
+    """
+    deleted = []
+    for subdir in (module_code, "core"):
+        legacy_path = Path(legacy_dir) / subdir / "module-help.csv"
+        if legacy_path.exists():
+            if verbose:
+                print(f"Deleting legacy CSV: {legacy_path}", file=sys.stderr)
+            legacy_path.unlink()
+            deleted.append(str(legacy_path))
+    return deleted
+
+
+def main():
+    args = parse_args()
+
+    # Read source entries
+    source_header, source_rows = read_csv_rows(args.source)
+    if not source_rows:
+        print(f"Error: No data rows found in source {args.source}", file=sys.stderr)
+        sys.exit(1)
+
+    # Determine module codes being merged
+    source_codes = extract_module_codes(source_rows)
+    if not source_codes:
+        print("Error: Could not determine module code from source rows", file=sys.stderr)
+        sys.exit(1)
+
+    if args.verbose:
+        print(f"Source module codes: {source_codes}", file=sys.stderr)
+        print(f"Source rows: {len(source_rows)}", file=sys.stderr)
+
+    # Read existing target (may not exist)
+    target_header, target_rows = read_csv_rows(args.target)
+    target_existed = Path(args.target).exists()
+
+    if args.verbose:
+        print(f"Target exists: {target_existed}", file=sys.stderr)
+        if target_existed:
+            print(f"Existing target rows: {len(target_rows)}", file=sys.stderr)
+
+    # Use source header if target doesn't exist or has no header
+    header = target_header if target_header else (source_header if source_header else HEADER)
+
+    # Anti-zombie: remove all rows for each source module code
+    filtered_rows = target_rows
+    removed_count = 0
+    for code in source_codes:
+        before_count = len(filtered_rows)
+        filtered_rows = filter_rows(filtered_rows, code)
+        removed_count += before_count - len(filtered_rows)
+
+    if args.verbose and removed_count > 0:
+        print(f"Removed {removed_count} existing rows (anti-zombie)", file=sys.stderr)
+
+    # Append source rows
+    merged_rows = filtered_rows + source_rows
+
+    # Write result
+    write_csv(args.target, header, merged_rows, args.verbose)
+
+    # Legacy cleanup: delete old per-module CSV files
+    legacy_deleted = []
+    if args.legacy_dir:
+        if not args.module_code:
+            print(
+                "Error: --module-code is required when --legacy-dir is provided",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        legacy_deleted = cleanup_legacy_csvs(
+            args.legacy_dir, args.module_code, args.verbose
+        )
+
+    # Output result summary as JSON
+    result = {
+        "status": "success",
+        "target_path": str(Path(args.target).resolve()),
+        "target_existed": target_existed,
+        "module_codes": sorted(source_codes),
+        "rows_removed": removed_count,
+        "rows_added": len(source_rows),
+        "total_rows": len(merged_rows),
+        "legacy_csvs_deleted": legacy_deleted,
+    }
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/lib/bmad-cache/bmb/skills/bmad-builder-setup/scripts/tests/test-cleanup-legacy.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.9"
+# dependencies = []
+# ///
+"""Unit tests for cleanup-legacy.py."""
+
+import json
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+# Add parent directory to path so we can import the module
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from importlib.util import spec_from_file_location, module_from_spec
+
+# Import cleanup_legacy module
+_spec = spec_from_file_location(
+    "cleanup_legacy",
+    str(Path(__file__).parent.parent / "cleanup-legacy.py"),
+)
+cleanup_legacy_mod = module_from_spec(_spec)
+_spec.loader.exec_module(cleanup_legacy_mod)
+
+find_skill_dirs = cleanup_legacy_mod.find_skill_dirs
+verify_skills_installed = cleanup_legacy_mod.verify_skills_installed
+count_files = cleanup_legacy_mod.count_files
+cleanup_directories = cleanup_legacy_mod.cleanup_directories
+
+
+def _make_skill_dir(base, *path_parts):
+    """Create a skill directory with a SKILL.md file."""
+    skill_dir = os.path.join(base, *path_parts)
+    os.makedirs(skill_dir, exist_ok=True)
+    with open(os.path.join(skill_dir, "SKILL.md"), "w") as f:
+        f.write("---\nname: test-skill\n---\n# Test\n")
+    return skill_dir
+
+
+def _make_file(base, *path_parts, content="placeholder"):
+    """Create a file at the given path."""
+    file_path = os.path.join(base, *path_parts)
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, "w") as f:
+        f.write(content)
+    return file_path
+
+
+class TestFindSkillDirs(unittest.TestCase):
+    def test_finds_dirs_with_skill_md(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            _make_skill_dir(tmpdir, "skills", "bmad-agent-builder")
+            _make_skill_dir(tmpdir, "skills", "bmad-workflow-builder")
+            result = find_skill_dirs(tmpdir)
+            self.assertEqual(result, ["bmad-agent-builder", "bmad-workflow-builder"])
+
+    def test_ignores_dirs_without_skill_md(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            _make_skill_dir(tmpdir, "skills", "real-skill")
+            os.makedirs(os.path.join(tmpdir, "skills", "not-a-skill"))
+            _make_file(tmpdir, "skills", "not-a-skill", "README.md")
+            result = find_skill_dirs(tmpdir)
+            self.assertEqual(result, ["real-skill"])
+
+    def test_empty_directory(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = find_skill_dirs(tmpdir)
+            self.assertEqual(result, [])
+
+    def test_nonexistent_directory(self):
+        result = find_skill_dirs("/nonexistent/path")
+        self.assertEqual(result, [])
+
+    def test_finds_nested_skills_in_phase_subdirs(self):
+        """Skills nested in phase directories like bmm/1-analysis/bmad-agent-analyst/."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            _make_skill_dir(tmpdir, "1-analysis", "bmad-agent-analyst")
+            _make_skill_dir(tmpdir, "2-plan", "bmad-agent-pm")
+            _make_skill_dir(tmpdir, "4-impl", "bmad-agent-dev")
+            result = find_skill_dirs(tmpdir)
+            self.assertEqual(
+                result, ["bmad-agent-analyst", "bmad-agent-dev", "bmad-agent-pm"]
+            )
+
+    def test_deduplicates_skill_names(self):
+        """If the same skill name appears in multiple locations, only listed once."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            _make_skill_dir(tmpdir, "a", "my-skill")
+            _make_skill_dir(tmpdir, "b", "my-skill")
+            result = find_skill_dirs(tmpdir)
+            self.assertEqual(result, ["my-skill"])
+
+
+class TestVerifySkillsInstalled(unittest.TestCase):
+    def test_all_skills_present(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            # Legacy: bmb has two skills
+            _make_skill_dir(bmad_dir, "bmb", "skills", "skill-a")
+            _make_skill_dir(bmad_dir, "bmb", "skills", "skill-b")
+
+            # Installed: both exist
+            os.makedirs(os.path.join(skills_dir, "skill-a"))
+            os.makedirs(os.path.join(skills_dir, "skill-b"))
+
+            result = verify_skills_installed(bmad_dir, ["bmb"], skills_dir)
+            self.assertEqual(result, ["skill-a", "skill-b"])
+
+    def test_missing_skill_exits_1(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            _make_skill_dir(bmad_dir, "bmb", "skills", "skill-a")
+            _make_skill_dir(bmad_dir, "bmb", "skills", "skill-missing")
+
+            # Only skill-a installed
+            os.makedirs(os.path.join(skills_dir, "skill-a"))
+
+            with self.assertRaises(SystemExit) as ctx:
+                verify_skills_installed(bmad_dir, ["bmb"], skills_dir)
+            self.assertEqual(ctx.exception.code, 1)
+
+    def test_empty_legacy_dir_passes(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+            os.makedirs(bmad_dir)
+            os.makedirs(skills_dir)
+
+            result = verify_skills_installed(bmad_dir, ["bmb"], skills_dir)
+            self.assertEqual(result, [])
+
+    def test_nonexistent_legacy_dir_skipped(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+            os.makedirs(skills_dir)
+            # bmad_dir doesn't exist — should not error
+
+            result = verify_skills_installed(bmad_dir, ["bmb"], skills_dir)
+            self.assertEqual(result, [])
+
+    def test_dir_without_skills_skipped(self):
+        """Directories like _config/ that have no SKILL.md are not verified."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            # _config has files but no SKILL.md
+            _make_file(bmad_dir, "_config", "manifest.yaml", content="version: 1")
+            _make_file(bmad_dir, "_config", "help.csv", content="a,b,c")
+            os.makedirs(skills_dir)
+
+            result = verify_skills_installed(bmad_dir, ["_config"], skills_dir)
+            self.assertEqual(result, [])
+
+    def test_verifies_across_multiple_dirs(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            _make_skill_dir(bmad_dir, "bmb", "skills", "skill-a")
+            _make_skill_dir(bmad_dir, "core", "skills", "skill-b")
+
+            os.makedirs(os.path.join(skills_dir, "skill-a"))
+            os.makedirs(os.path.join(skills_dir, "skill-b"))
+
+            result = verify_skills_installed(
+                bmad_dir, ["bmb", "core"], skills_dir
+            )
+            self.assertEqual(result, ["skill-a", "skill-b"])
+
+
+class TestCountFiles(unittest.TestCase):
+    def test_counts_files_recursively(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            _make_file(tmpdir, "a.txt")
+            _make_file(tmpdir, "sub", "b.txt")
+            _make_file(tmpdir, "sub", "deep", "c.txt")
+            self.assertEqual(count_files(Path(tmpdir)), 3)
+
+    def test_empty_dir_returns_zero(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self.assertEqual(count_files(Path(tmpdir)), 0)
+
+
+class TestCleanupDirectories(unittest.TestCase):
+    def test_removes_single_module_dir(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            os.makedirs(os.path.join(bmad_dir, "bmb", "skills"))
+            _make_file(bmad_dir, "bmb", "skills", "SKILL.md")
+
+            removed, not_found, count = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed, ["bmb"])
+            self.assertEqual(not_found, [])
+            self.assertGreater(count, 0)
+            self.assertFalse(os.path.exists(os.path.join(bmad_dir, "bmb")))
+
+    def test_removes_module_core_and_config(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            for dirname in ("bmb", "core", "_config"):
+                _make_file(bmad_dir, dirname, "some-file.txt")
+
+            removed, not_found, count = cleanup_directories(
+                bmad_dir, ["bmb", "core", "_config"]
+            )
+            self.assertEqual(sorted(removed), ["_config", "bmb", "core"])
+            self.assertEqual(not_found, [])
+            for dirname in ("bmb", "core", "_config"):
+                self.assertFalse(os.path.exists(os.path.join(bmad_dir, dirname)))
+
+    def test_nonexistent_dir_in_not_found(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            os.makedirs(bmad_dir)
+
+            removed, not_found, count = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed, [])
+            self.assertEqual(not_found, ["bmb"])
+            self.assertEqual(count, 0)
+
+    def test_preserves_other_module_dirs(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            for dirname in ("bmb", "bmm", "tea"):
+                _make_file(bmad_dir, dirname, "file.txt")
+
+            removed, not_found, count = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed, ["bmb"])
+            self.assertTrue(os.path.isdir(os.path.join(bmad_dir, "bmm")))
+            self.assertTrue(os.path.isdir(os.path.join(bmad_dir, "tea")))
+
+    def test_preserves_root_config_files(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            _make_file(bmad_dir, "config.yaml", content="key: val")
+            _make_file(bmad_dir, "config.user.yaml", content="user: test")
+            _make_file(bmad_dir, "module-help.csv", content="a,b,c")
+            _make_file(bmad_dir, "bmb", "stuff.txt")
+
+            cleanup_directories(bmad_dir, ["bmb"])
+
+            self.assertTrue(os.path.exists(os.path.join(bmad_dir, "config.yaml")))
+            self.assertTrue(
+                os.path.exists(os.path.join(bmad_dir, "config.user.yaml"))
+            )
+            self.assertTrue(
+                os.path.exists(os.path.join(bmad_dir, "module-help.csv"))
+            )
+
+    def test_removes_hidden_files(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            _make_file(bmad_dir, "bmb", ".DS_Store")
+            _make_file(bmad_dir, "bmb", "skills", ".hidden")
+
+            removed, not_found, count = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed, ["bmb"])
+            self.assertEqual(count, 2)
+            self.assertFalse(os.path.exists(os.path.join(bmad_dir, "bmb")))
+
+    def test_idempotent_rerun(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            _make_file(bmad_dir, "bmb", "file.txt")
+
+            # First run
+            removed1, not_found1, _ = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed1, ["bmb"])
+            self.assertEqual(not_found1, [])
+
+            # Second run — idempotent
+            removed2, not_found2, count2 = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed2, [])
+            self.assertEqual(not_found2, ["bmb"])
+            self.assertEqual(count2, 0)
+
+
+class TestSafetyCheck(unittest.TestCase):
+    def test_no_skills_dir_skips_check(self):
+        """When --skills-dir is not provided, no verification happens."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            _make_skill_dir(bmad_dir, "bmb", "skills", "some-skill")
+
+            # No skills_dir — cleanup should proceed without verification
+            removed, not_found, count = cleanup_directories(bmad_dir, ["bmb"])
+            self.assertEqual(removed, ["bmb"])
+
+    def test_missing_skill_blocks_removal(self):
+        """When --skills-dir is provided and a skill is missing, exit 1."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            _make_skill_dir(bmad_dir, "bmb", "skills", "installed-skill")
+            _make_skill_dir(bmad_dir, "bmb", "skills", "missing-skill")
+
+            os.makedirs(os.path.join(skills_dir, "installed-skill"))
+            # missing-skill not created in skills_dir
+
+            with self.assertRaises(SystemExit) as ctx:
+                verify_skills_installed(bmad_dir, ["bmb"], skills_dir)
+            self.assertEqual(ctx.exception.code, 1)
+
+            # Directory should NOT have been removed (verification failed before cleanup)
+            self.assertTrue(os.path.isdir(os.path.join(bmad_dir, "bmb")))
+
+    def test_dir_without_skills_not_checked(self):
+        """Directories like _config that have no SKILL.md pass verification."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            _make_file(bmad_dir, "_config", "manifest.yaml")
+            os.makedirs(skills_dir)
+
+            # Should not raise — _config has no skills to verify
+            result = verify_skills_installed(bmad_dir, ["_config"], skills_dir)
+            self.assertEqual(result, [])
+
+
+class TestEndToEnd(unittest.TestCase):
+    def test_full_cleanup_with_verification(self):
+        """Simulate complete cleanup flow with safety check."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+            skills_dir = os.path.join(tmpdir, "skills")
+
+            # Create legacy structure
+            _make_skill_dir(bmad_dir, "bmb", "skills", "bmad-agent-builder")
+            _make_skill_dir(bmad_dir, "bmb", "skills", "bmad-builder-setup")
+            _make_file(bmad_dir, "bmb", "skills", "bmad-agent-builder", "assets", "template.md")
+            _make_skill_dir(bmad_dir, "core", "skills", "bmad-brainstorming")
+            _make_file(bmad_dir, "_config", "manifest.yaml")
+            _make_file(bmad_dir, "_config", "bmad-help.csv")
+
+            # Create root config files that must survive
+            _make_file(bmad_dir, "config.yaml", content="document_output_language: English")
+            _make_file(bmad_dir, "config.user.yaml", content="user_name: Test")
+            _make_file(bmad_dir, "module-help.csv", content="module,name\nbmb,builder")
+
+            # Create other module dirs that must survive
+            _make_file(bmad_dir, "bmm", "config.yaml")
+            _make_file(bmad_dir, "tea", "config.yaml")
+
+            # Create installed skills
+            os.makedirs(os.path.join(skills_dir, "bmad-agent-builder"))
+            os.makedirs(os.path.join(skills_dir, "bmad-builder-setup"))
+            os.makedirs(os.path.join(skills_dir, "bmad-brainstorming"))
+
+            # Verify
+            verified = verify_skills_installed(
+                bmad_dir, ["bmb", "core", "_config"], skills_dir
+            )
+            self.assertIn("bmad-agent-builder", verified)
+            self.assertIn("bmad-builder-setup", verified)
+            self.assertIn("bmad-brainstorming", verified)
+
+            # Cleanup
+            removed, not_found, file_count = cleanup_directories(
+                bmad_dir, ["bmb", "core", "_config"]
+            )
+            self.assertEqual(sorted(removed), ["_config", "bmb", "core"])
+            self.assertEqual(not_found, [])
+            self.assertGreater(file_count, 0)
+
+            # Verify final state
+            self.assertFalse(os.path.exists(os.path.join(bmad_dir, "bmb")))
+            self.assertFalse(os.path.exists(os.path.join(bmad_dir, "core")))
+            self.assertFalse(os.path.exists(os.path.join(bmad_dir, "_config")))
+
+            # Root config files survived
+            self.assertTrue(os.path.exists(os.path.join(bmad_dir, "config.yaml")))
+            self.assertTrue(os.path.exists(os.path.join(bmad_dir, "config.user.yaml")))
+            self.assertTrue(os.path.exists(os.path.join(bmad_dir, "module-help.csv")))
+
+            # Other modules survived
+            self.assertTrue(os.path.isdir(os.path.join(bmad_dir, "bmm")))
+            self.assertTrue(os.path.isdir(os.path.join(bmad_dir, "tea")))
+
+    def test_simulate_post_merge_scripts(self):
+        """Simulate the full flow: merge scripts run first (delete config files),
+        then cleanup removes directories."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            bmad_dir = os.path.join(tmpdir, "_bmad")
+
+            # Legacy state: config files already deleted by merge scripts
+            # but directories and skill content remain
+            _make_skill_dir(bmad_dir, "bmb", "skills", "bmad-agent-builder")
+            _make_file(bmad_dir, "bmb", "skills", "bmad-agent-builder", "refs", "doc.md")
+            _make_file(bmad_dir, "bmb", ".DS_Store")
+            # config.yaml already deleted by merge-config.py
+            # module-help.csv already deleted by merge-help-csv.py
+
+            _make_skill_dir(bmad_dir, "core", "skills", "bmad-help")
+            # core/config.yaml already deleted
+            # core/module-help.csv already deleted
+
+            # Root files from merge scripts
+            _make_file(bmad_dir, "config.yaml", content="bmb:\n  name: BMad Builder")
+            _make_file(bmad_dir, "config.user.yaml", content="user_name: Test")
+            _make_file(bmad_dir, "module-help.csv", content="module,name")
+
+            # Cleanup directories
+            removed, not_found, file_count = cleanup_directories(
+                bmad_dir, ["bmb", "core"]
+            )
+            self.assertEqual(sorted(removed), ["bmb", "core"])
+            self.assertGreater(file_count, 0)
+
+            # Final state: only root config files
+            remaining = os.listdir(bmad_dir)
+            self.assertEqual(
+                sorted(remaining),
+                ["config.user.yaml", "config.yaml", "module-help.csv"],
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()