ma-agents 3.5.0 → 3.5.2

package/lib/bmad-cache/bmb/skills/bmad-module-builder/scripts/tests/test-scaffold-setup-skill.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# ///
+"""Tests for scaffold-setup-skill.py"""
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parent.parent / "scaffold-setup-skill.py"
+TEMPLATE_DIR = Path(__file__).resolve().parent.parent.parent / "assets" / "setup-skill-template"
+
+
+def run_scaffold(tmp: Path, **kwargs) -> tuple[int, dict]:
+    """Run the scaffold script and return (exit_code, parsed_json)."""
+    target_dir = kwargs.get("target_dir", str(tmp / "output"))
+    Path(target_dir).mkdir(parents=True, exist_ok=True)
+
+    module_code = kwargs.get("module_code", "tst")
+    module_name = kwargs.get("module_name", "Test Module")
+
+    yaml_path = tmp / "module.yaml"
+    csv_path = tmp / "module-help.csv"
+    yaml_path.write_text(kwargs.get("yaml_content", f'code: {module_code}\nname: "{module_name}"\n'))
+    csv_path.write_text(
+        kwargs.get(
+            "csv_content",
+            "module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs\n"
+            f'{module_name},{module_code}-example,Example,EX,An example skill,do-thing,,anytime,,,false,output_folder,artifact\n',
+        )
+    )
+
+    cmd = [
+        sys.executable,
+        str(SCRIPT),
+        "--target-dir", target_dir,
+        "--module-code", module_code,
+        "--module-name", module_name,
+        "--module-yaml", str(yaml_path),
+        "--module-csv", str(csv_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        data = {"raw_stdout": result.stdout, "raw_stderr": result.stderr}
+    return result.returncode, data
+
+
+def test_basic_scaffold():
+    """Test that scaffolding creates the expected structure."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        target_dir = tmp / "output"
+        target_dir.mkdir()
+
+        code, data = run_scaffold(tmp, target_dir=str(target_dir))
+        assert code == 0, f"Script failed: {data}"
+        assert data["status"] == "success"
+        assert data["setup_skill"] == "tst-setup"
+
+        setup_dir = target_dir / "tst-setup"
+        assert setup_dir.is_dir()
+        assert (setup_dir / "SKILL.md").is_file()
+        assert (setup_dir / "scripts" / "merge-config.py").is_file()
+        assert (setup_dir / "scripts" / "merge-help-csv.py").is_file()
+        assert (setup_dir / "scripts" / "cleanup-legacy.py").is_file()
+        assert (setup_dir / "assets" / "module.yaml").is_file()
+        assert (setup_dir / "assets" / "module-help.csv").is_file()
+
+
+def test_skill_md_frontmatter_substitution():
+    """Test that SKILL.md placeholders are replaced."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        target_dir = tmp / "output"
+        target_dir.mkdir()
+
+        code, data = run_scaffold(
+            tmp,
+            target_dir=str(target_dir),
+            module_code="xyz",
+            module_name="XYZ Studio",
+        )
+        assert code == 0
+
+        skill_md = (target_dir / "xyz-setup" / "SKILL.md").read_text()
+        assert "xyz-setup" in skill_md
+        assert "XYZ Studio" in skill_md
+        assert "{setup-skill-name}" not in skill_md
+        assert "{module-name}" not in skill_md
+        assert "{module-code}" not in skill_md
+
+
+def test_generated_files_written():
+    """Test that module.yaml and module-help.csv contain generated content."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        target_dir = tmp / "output"
+        target_dir.mkdir()
+
+        custom_yaml = 'code: abc\nname: "ABC Module"\ndescription: "Custom desc"\n'
+        custom_csv = "module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs\nABC Module,bmad-abc-thing,Do Thing,DT,Does the thing,run,,anytime,,,false,output_folder,report\n"
+
+        code, data = run_scaffold(
+            tmp,
+            target_dir=str(target_dir),
+            module_code="abc",
+            module_name="ABC Module",
+            yaml_content=custom_yaml,
+            csv_content=custom_csv,
+        )
+        assert code == 0
+
+        yaml_content = (target_dir / "abc-setup" / "assets" / "module.yaml").read_text()
+        assert "ABC Module" in yaml_content
+        assert "Custom desc" in yaml_content
+
+        csv_content = (target_dir / "abc-setup" / "assets" / "module-help.csv").read_text()
+        assert "bmad-abc-thing" in csv_content
+        assert "DT" in csv_content
+
+
+def test_anti_zombie_replaces_existing():
+    """Test that an existing setup skill is replaced cleanly."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        target_dir = tmp / "output"
+        target_dir.mkdir()
+
+        # First scaffold
+        run_scaffold(tmp, target_dir=str(target_dir))
+        stale_file = target_dir / "tst-setup" / "stale-marker.txt"
+        stale_file.write_text("should be removed")
+
+        # Second scaffold should remove stale file
+        code, data = run_scaffold(tmp, target_dir=str(target_dir))
+        assert code == 0
+        assert not stale_file.exists()
+
+
+def test_missing_target_dir():
+    """Test error when target directory doesn't exist."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        nonexistent = tmp / "nonexistent"
+
+        # Write valid source files
+        yaml_path = tmp / "module.yaml"
+        csv_path = tmp / "module-help.csv"
+        yaml_path.write_text('code: tst\nname: "Test"\n')
+        csv_path.write_text("header\n")
+
+        cmd = [
+            sys.executable,
+            str(SCRIPT),
+            "--target-dir", str(nonexistent),
+            "--module-code", "tst",
+            "--module-name", "Test",
+            "--module-yaml", str(yaml_path),
+            "--module-csv", str(csv_path),
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        assert result.returncode == 2
+        data = json.loads(result.stdout)
+        assert data["status"] == "error"
+
+
+def test_missing_source_file():
+    """Test error when module.yaml source doesn't exist."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        target_dir = tmp / "output"
+        target_dir.mkdir()
+
+        # Remove the yaml after creation to simulate missing file
+        yaml_path = tmp / "module.yaml"
+        csv_path = tmp / "module-help.csv"
+        csv_path.write_text("header\n")
+        # Don't create yaml_path
+
+        cmd = [
+            sys.executable,
+            str(SCRIPT),
+            "--target-dir", str(target_dir),
+            "--module-code", "tst",
+            "--module-name", "Test",
+            "--module-yaml", str(yaml_path),
+            "--module-csv", str(csv_path),
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        assert result.returncode == 2
+        data = json.loads(result.stdout)
+        assert data["status"] == "error"
+
+
+if __name__ == "__main__":
+    tests = [
+        test_basic_scaffold,
+        test_skill_md_frontmatter_substitution,
+        test_generated_files_written,
+        test_anti_zombie_replaces_existing,
+        test_missing_target_dir,
+        test_missing_source_file,
+    ]
+    passed = 0
+    failed = 0
+    for test in tests:
+        try:
+            test()
+            print(f"  PASS: {test.__name__}")
+            passed += 1
+        except AssertionError as e:
+            print(f"  FAIL: {test.__name__}: {e}")
+            failed += 1
+        except Exception as e:
+            print(f"  ERROR: {test.__name__}: {e}")
+            failed += 1
+    print(f"\n{passed} passed, {failed} failed")
+    sys.exit(1 if failed else 0)

package/lib/bmad-cache/bmb/skills/bmad-module-builder/scripts/tests/test-scaffold-standalone-module.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# ///
+"""Tests for scaffold-standalone-module.py"""
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parent.parent / "scaffold-standalone-module.py"
+
+
+def make_skill_dir(tmp: Path, name: str = "my-skill") -> Path:
+    """Create a minimal skill directory with SKILL.md and assets/module.yaml."""
+    skill_dir = tmp / name
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    (skill_dir / "SKILL.md").write_text("---\nname: my-skill\ndescription: A test skill\n---\n# My Skill\n")
+    assets = skill_dir / "assets"
+    assets.mkdir(exist_ok=True)
+    (assets / "module.yaml").write_text(
+        'code: tst\nname: "Test Module"\ndescription: "A test module"\nmodule_version: 1.0.0\n'
+    )
+    (assets / "module-help.csv").write_text(
+        "module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs\n"
+        "Test Module,my-skill,Do Thing,DT,Does the thing,run,,anytime,,,false,output_folder,artifact\n"
+    )
+    return skill_dir
+
+
+def run_scaffold(skill_dir: Path, **kwargs) -> tuple[int, dict]:
+    """Run the standalone scaffold script and return (exit_code, parsed_json)."""
+    cmd = [
+        sys.executable,
+        str(SCRIPT),
+        "--skill-dir", str(skill_dir),
+        "--module-code", kwargs.get("module_code", "tst"),
+        "--module-name", kwargs.get("module_name", "Test Module"),
+    ]
+    if "marketplace_dir" in kwargs:
+        cmd.extend(["--marketplace-dir", str(kwargs["marketplace_dir"])])
+    if kwargs.get("verbose"):
+        cmd.append("--verbose")
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        data = {"raw_stdout": result.stdout, "raw_stderr": result.stderr}
+    return result.returncode, data
+
+
+def test_basic_scaffold():
+    """Test that scaffolding copies all expected template files."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = make_skill_dir(tmp)
+
+        code, data = run_scaffold(skill_dir)
+        assert code == 0, f"Script failed: {data}"
+        assert data["status"] == "success"
+        assert data["module_code"] == "tst"
+
+        # module-setup.md placed alongside module.yaml in assets/
+        assert (skill_dir / "assets" / "module-setup.md").is_file()
+        # merge scripts placed in scripts/
+        assert (skill_dir / "scripts" / "merge-config.py").is_file()
+        assert (skill_dir / "scripts" / "merge-help-csv.py").is_file()
+        # marketplace.json at parent level
+        assert (tmp / ".claude-plugin" / "marketplace.json").is_file()
+
+
+def test_marketplace_json_content():
+    """Test that marketplace.json contains correct module metadata."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = make_skill_dir(tmp, name="bmad-exc-tools")
+
+        code, data = run_scaffold(
+            skill_dir, module_code="exc", module_name="Excalidraw Tools"
+        )
+        assert code == 0
+
+        marketplace = json.loads(
+            (tmp / ".claude-plugin" / "marketplace.json").read_text()
+        )
+        assert marketplace["name"] == "bmad-exc"
+        plugin = marketplace["plugins"][0]
+        assert plugin["name"] == "bmad-exc"
+        assert plugin["skills"] == ["./bmad-exc-tools"]
+        assert plugin["description"] == "A test module"
+        assert plugin["version"] == "1.0.0"
+
+
+def test_does_not_overwrite_existing_scripts():
+    """Test that existing scripts are skipped with a warning."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = make_skill_dir(tmp)
+
+        # Pre-create a merge-config.py with custom content
+        scripts_dir = skill_dir / "scripts"
+        scripts_dir.mkdir(exist_ok=True)
+        existing_script = scripts_dir / "merge-config.py"
+        existing_script.write_text("# my custom script\n")
+
+        code, data = run_scaffold(skill_dir)
+        assert code == 0
+
+        # Should be skipped
+        assert "scripts/merge-config.py" in data["files_skipped"]
+        assert len(data["warnings"]) >= 1
+        assert any("merge-config.py" in w for w in data["warnings"])
+
+        # Content should be preserved
+        assert existing_script.read_text() == "# my custom script\n"
+
+        # merge-help-csv.py should still be created
+        assert "scripts/merge-help-csv.py" in data["files_created"]
+
+
+def test_creates_missing_subdirectories():
+    """Test that scripts/ directory is created if it doesn't exist."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = make_skill_dir(tmp)
+
+        # Verify scripts/ doesn't exist yet
+        assert not (skill_dir / "scripts").exists()
+
+        code, data = run_scaffold(skill_dir)
+        assert code == 0
+        assert (skill_dir / "scripts").is_dir()
+        assert (skill_dir / "scripts" / "merge-config.py").is_file()
+
+
+def test_preserves_existing_skill_files():
+    """Test that existing skill files are not modified or deleted."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = make_skill_dir(tmp)
+
+        # Add extra files
+        (skill_dir / "build-process.md").write_text("# Build\n")
+        refs_dir = skill_dir / "references"
+        refs_dir.mkdir()
+        (refs_dir / "my-ref.md").write_text("# Reference\n")
+
+        original_skill_md = (skill_dir / "SKILL.md").read_text()
+
+        code, data = run_scaffold(skill_dir)
+        assert code == 0
+
+        # Original files untouched
+        assert (skill_dir / "SKILL.md").read_text() == original_skill_md
+        assert (skill_dir / "build-process.md").read_text() == "# Build\n"
+        assert (refs_dir / "my-ref.md").read_text() == "# Reference\n"
+
+
+def test_missing_skill_dir():
+    """Test error when skill directory doesn't exist."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        nonexistent = tmp / "nonexistent-skill"
+
+        cmd = [
+            sys.executable, str(SCRIPT),
+            "--skill-dir", str(nonexistent),
+            "--module-code", "tst",
+            "--module-name", "Test",
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        assert result.returncode == 2
+        data = json.loads(result.stdout)
+        assert data["status"] == "error"
+
+
+def test_missing_skill_md():
+    """Test error when skill directory has no SKILL.md."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = tmp / "empty-skill"
+        skill_dir.mkdir()
+        (skill_dir / "assets").mkdir()
+        (skill_dir / "assets" / "module.yaml").write_text("code: tst\n")
+
+        cmd = [
+            sys.executable, str(SCRIPT),
+            "--skill-dir", str(skill_dir),
+            "--module-code", "tst",
+            "--module-name", "Test",
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        assert result.returncode == 2
+        data = json.loads(result.stdout)
+        assert data["status"] == "error"
+        assert "SKILL.md" in data["message"]
+
+
+def test_missing_module_yaml():
+    """Test error when assets/module.yaml hasn't been written yet."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = tmp / "skill-no-yaml"
+        skill_dir.mkdir()
+        (skill_dir / "SKILL.md").write_text("---\nname: test\n---\n")
+
+        cmd = [
+            sys.executable, str(SCRIPT),
+            "--skill-dir", str(skill_dir),
+            "--module-code", "tst",
+            "--module-name", "Test",
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        assert result.returncode == 2
+        data = json.loads(result.stdout)
+        assert data["status"] == "error"
+        assert "module.yaml" in data["message"]
+
+
+def test_custom_marketplace_dir():
+    """Test that --marketplace-dir places marketplace.json in a custom location."""
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        skill_dir = make_skill_dir(tmp)
+        custom_dir = tmp / "custom-root"
+        custom_dir.mkdir()
+
+        code, data = run_scaffold(skill_dir, marketplace_dir=custom_dir)
+        assert code == 0
+
+        # Should be at custom location, not default parent
+        assert (custom_dir / ".claude-plugin" / "marketplace.json").is_file()
+        assert not (tmp / ".claude-plugin" / "marketplace.json").exists()
+        assert data["marketplace_json"] == str((custom_dir / ".claude-plugin" / "marketplace.json").resolve())
+
+
+if __name__ == "__main__":
+    tests = [
+        test_basic_scaffold,
+        test_marketplace_json_content,
+        test_does_not_overwrite_existing_scripts,
+        test_creates_missing_subdirectories,
+        test_preserves_existing_skill_files,
+        test_missing_skill_dir,
+        test_missing_skill_md,
+        test_missing_module_yaml,
+        test_custom_marketplace_dir,
+    ]
+    passed = 0
+    failed = 0
+    for test in tests:
+        try:
+            test()
+            print(f"  PASS: {test.__name__}")
+            passed += 1
+        except AssertionError as e:
+            print(f"  FAIL: {test.__name__}: {e}")
+            failed += 1
+        except Exception as e:
+            print(f"  ERROR: {test.__name__}: {e}")
+            failed += 1
+    print(f"\n{passed} passed, {failed} failed")
+    sys.exit(1 if failed else 0)