ma-agents 3.4.9 → 3.5.1

package/lib/bmad-cache/bmb/skills/bmad-agent-builder/scripts/prepass-sanctum-architecture.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""Deterministic pre-pass for sanctum architecture scanner.
+
+Extracts structural metadata from a memory agent's sanctum architecture
+that the LLM scanner can use instead of reading all files itself. Covers:
+- SKILL.md content line count (non-blank, non-frontmatter)
+- Template file inventory (which of the 6 standard templates exist)
+- CREED template section inventory
+- BOND template section inventory
+- Capability reference frontmatter fields
+- Init script parameter extraction (SKILL_NAME, TEMPLATE_FILES, EVOLVABLE)
+- First-breath.md section inventory
+- PULSE template presence and sections
+
+Only runs for memory agents (agents with assets/ containing template files).
+"""
+
+# /// script
+# requires-python = ">=3.9"
+# dependencies = []
+# ///
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+STANDARD_TEMPLATES = [
+    "INDEX-template.md",
+    "PERSONA-template.md",
+    "CREED-template.md",
+    "BOND-template.md",
+    "MEMORY-template.md",
+    "CAPABILITIES-template.md",
+]
+
+OPTIONAL_TEMPLATES = [
+    "PULSE-template.md",
+]
+
+CREED_REQUIRED_SECTIONS = [
+    "The Sacred Truth",
+    "Mission",
+    "Core Values",
+    "Standing Orders",
+    "Philosophy",
+    "Boundaries",
+    "Anti-Patterns",
+    "Dominion",
+]
+
+FIRST_BREATH_CALIBRATION_SECTIONS = [
+    "Save As You Go",
+    "Pacing",
+    "Chase What Catches",
+    "Absorb Their Voice",
+    "Show Your Work",
+    "Hear the Silence",
+    "The Territories",
+    "Wrapping Up",
+]
+
+FIRST_BREATH_CONFIG_SECTIONS = [
+    "Save As You Go",
+    "Discovery",
+    "Urgency",
+    "Wrapping Up",
+]
+
+
+def count_content_lines(file_path: Path) -> int:
+    """Count non-blank, non-frontmatter lines in a markdown file."""
+    content = file_path.read_text()
+
+    # Strip frontmatter
+    stripped = re.sub(r"^---\s*\n.*?\n---\s*\n", "", content, count=1, flags=re.DOTALL)
+
+    lines = [line for line in stripped.split("\n") if line.strip()]
+    return len(lines)
+
+
+def extract_h2_h3_sections(file_path: Path) -> list[str]:
+    """Extract H2 and H3 headings from a markdown file."""
+    sections = []
+    if not file_path.exists():
+        return sections
+    for line in file_path.read_text().split("\n"):
+        match = re.match(r"^#{2,3}\s+(.+)", line)
+        if match:
+            sections.append(match.group(1).strip())
+    return sections
+
+
+def parse_frontmatter(file_path: Path) -> dict:
+    """Extract YAML frontmatter from a markdown file."""
+    meta = {}
+    content = file_path.read_text()
+    match = re.match(r"^---\s*\n(.*?)\n---", content, re.DOTALL)
+    if not match:
+        return meta
+    for line in match.group(1).strip().split("\n"):
+        if ":" in line:
+            key, _, value = line.partition(":")
+            meta[key.strip()] = value.strip().strip("'\"")
+    return meta
+
+
+def extract_init_script_params(script_path: Path) -> dict:
+    """Extract agent-specific configuration from init-sanctum.py."""
+    params = {
+        "exists": script_path.exists(),
+        "skill_name": None,
+        "template_files": [],
+        "skill_only_files": [],
+        "evolvable": None,
+    }
+    if not script_path.exists():
+        return params
+
+    content = script_path.read_text()
+
+    # SKILL_NAME
+    match = re.search(r'SKILL_NAME\s*=\s*["\']([^"\']+)["\']', content)
+    if match:
+        params["skill_name"] = match.group(1)
+
+    # TEMPLATE_FILES
+    tmpl_match = re.search(
+        r"TEMPLATE_FILES\s*=\s*\[(.*?)\]", content, re.DOTALL
+    )
+    if tmpl_match:
+        params["template_files"] = re.findall(r'["\']([^"\']+)["\']', tmpl_match.group(1))
+
+    # SKILL_ONLY_FILES
+    only_match = re.search(
+        r"SKILL_ONLY_FILES\s*=\s*\{(.*?)\}", content, re.DOTALL
+    )
+    if only_match:
+        params["skill_only_files"] = re.findall(r'["\']([^"\']+)["\']', only_match.group(1))
+
+    # EVOLVABLE
+    ev_match = re.search(r"EVOLVABLE\s*=\s*(True|False)", content)
+    if ev_match:
+        params["evolvable"] = ev_match.group(1) == "True"
+
+    return params
+
+
+def check_section_present(sections: list[str], keyword: str) -> bool:
+    """Check if any section heading contains the keyword (case-insensitive)."""
+    keyword_lower = keyword.lower()
+    return any(keyword_lower in s.lower() for s in sections)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Pre-pass for sanctum architecture scanner"
+    )
+    parser.add_argument("skill_path", help="Path to the agent skill directory")
+    parser.add_argument(
+        "-o", "--output", help="Output JSON file path (default: stdout)"
+    )
+    args = parser.parse_args()
+
+    skill_path = Path(args.skill_path).resolve()
+    if not skill_path.is_dir():
+        print(f"Error: {skill_path} is not a directory", file=sys.stderr)
+        sys.exit(2)
+
+    assets_dir = skill_path / "assets"
+    references_dir = skill_path / "references"
+    scripts_dir = skill_path / "scripts"
+    skill_md = skill_path / "SKILL.md"
+
+    # Check if this is a memory agent (has template files in assets/)
+    is_memory_agent = assets_dir.exists() and any(
+        f.name.endswith("-template.md") for f in assets_dir.iterdir() if f.is_file()
+    )
+
+    if not is_memory_agent:
+        result = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "skill_path": str(skill_path),
+            "is_memory_agent": False,
+            "message": "Not a memory agent — no sanctum templates found in assets/",
+        }
+        output_json(result, args.output)
+        return
+
+    # SKILL.md analysis
+    skill_analysis = {
+        "exists": skill_md.exists(),
+        "content_lines": count_content_lines(skill_md) if skill_md.exists() else 0,
+        "sections": extract_h2_h3_sections(skill_md) if skill_md.exists() else [],
+    }
+
+    # Template inventory
+    template_inventory = {}
+    for tmpl in STANDARD_TEMPLATES:
+        tmpl_path = assets_dir / tmpl
+        template_inventory[tmpl] = {
+            "exists": tmpl_path.exists(),
+            "sections": extract_h2_h3_sections(tmpl_path) if tmpl_path.exists() else [],
+            "content_lines": count_content_lines(tmpl_path) if tmpl_path.exists() else 0,
+        }
+
+    for tmpl in OPTIONAL_TEMPLATES:
+        tmpl_path = assets_dir / tmpl
+        template_inventory[tmpl] = {
+            "exists": tmpl_path.exists(),
+            "optional": True,
+            "sections": extract_h2_h3_sections(tmpl_path) if tmpl_path.exists() else [],
+            "content_lines": count_content_lines(tmpl_path) if tmpl_path.exists() else 0,
+        }
+
+    # CREED section check
+    creed_path = assets_dir / "CREED-template.md"
+    creed_sections = extract_h2_h3_sections(creed_path) if creed_path.exists() else []
+    creed_check = {}
+    for section in CREED_REQUIRED_SECTIONS:
+        creed_check[section] = check_section_present(creed_sections, section)
+
+    # First-breath analysis
+    first_breath_path = references_dir / "first-breath.md"
+    fb_sections = extract_h2_h3_sections(first_breath_path) if first_breath_path.exists() else []
+
+    # Detect style: calibration has "Absorb Their Voice", configuration has "Discovery"
+    is_calibration = check_section_present(fb_sections, "Absorb")
+    is_configuration = check_section_present(fb_sections, "Discovery") and not is_calibration
+    fb_style = "calibration" if is_calibration else ("configuration" if is_configuration else "unknown")
+
+    expected_sections = (
+        FIRST_BREATH_CALIBRATION_SECTIONS if is_calibration else FIRST_BREATH_CONFIG_SECTIONS
+    )
+    fb_check = {}
+    for section in expected_sections:
+        fb_check[section] = check_section_present(fb_sections, section)
+
+    first_breath_analysis = {
+        "exists": first_breath_path.exists(),
+        "style": fb_style,
+        "sections": fb_sections,
+        "section_checks": fb_check,
+    }
+
+    # Capability frontmatter scan
+    capabilities = []
+    if references_dir.exists():
+        for md_file in sorted(references_dir.glob("*.md")):
+            if md_file.name == "first-breath.md":
+                continue
+            meta = parse_frontmatter(md_file)
+            if meta:
+                cap_info = {
+                    "file": md_file.name,
+                    "has_name": "name" in meta,
+                    "has_code": "code" in meta,
+                    "has_description": "description" in meta,
+                    "sections": extract_h2_h3_sections(md_file),
+                }
+                # Check for memory agent patterns
+                cap_info["has_memory_integration"] = check_section_present(
+                    cap_info["sections"], "Memory Integration"
+                )
+                cap_info["has_after_session"] = check_section_present(
+                    cap_info["sections"], "After"
+                )
+                cap_info["has_success"] = check_section_present(
+                    cap_info["sections"], "Success"
+                )
+                capabilities.append(cap_info)
+
+    # Init script analysis
+    init_script_path = scripts_dir / "init-sanctum.py"
+    init_params = extract_init_script_params(init_script_path)
+
+    # Cross-check: init TEMPLATE_FILES vs actual templates
+    actual_templates = [f.name for f in assets_dir.iterdir() if f.name.endswith("-template.md")] if assets_dir.exists() else []
+    init_template_match = set(init_params.get("template_files", [])) == set(actual_templates) if init_params["exists"] else None
+
+    # Cross-check: init SKILL_NAME vs folder name
+    skill_name_match = init_params.get("skill_name") == skill_path.name if init_params["exists"] else None
+
+    # Findings
+    findings = []
+
+    if skill_analysis["content_lines"] > 40:
+        findings.append({
+            "severity": "high",
+            "file": "SKILL.md",
+            "message": f"Bootloader has {skill_analysis['content_lines']} content lines (target: ~30, max: 40)",
+        })
+
+    for tmpl in STANDARD_TEMPLATES:
+        if not template_inventory[tmpl]["exists"]:
+            findings.append({
+                "severity": "critical",
+                "file": f"assets/{tmpl}",
+                "message": f"Missing standard template: {tmpl}",
+            })
+
+    for section, present in creed_check.items():
+        if not present:
+            findings.append({
+                "severity": "high",
+                "file": "assets/CREED-template.md",
+                "message": f"Missing required CREED section: {section}",
+            })
+
+    if not first_breath_analysis["exists"]:
+        findings.append({
+            "severity": "critical",
+            "file": "references/first-breath.md",
+            "message": "Missing first-breath.md",
+        })
+    else:
+        for section, present in first_breath_analysis["section_checks"].items():
+            if not present:
+                findings.append({
+                    "severity": "high",
+                    "file": "references/first-breath.md",
+                    "message": f"Missing First Breath section: {section}",
+                })
+
+    if not init_params["exists"]:
+        findings.append({
+            "severity": "critical",
+            "file": "scripts/init-sanctum.py",
+            "message": "Missing init-sanctum.py",
+        })
+    else:
+        if skill_name_match is False:
+            findings.append({
+                "severity": "critical",
+                "file": "scripts/init-sanctum.py",
+                "message": f"SKILL_NAME mismatch: script has '{init_params['skill_name']}', folder is '{skill_path.name}'",
+            })
+        if init_template_match is False:
+            findings.append({
+                "severity": "high",
+                "file": "scripts/init-sanctum.py",
+                "message": "TEMPLATE_FILES does not match actual templates in assets/",
+            })
+
+    result = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "skill_path": str(skill_path),
+        "is_memory_agent": True,
+        "skill_md": skill_analysis,
+        "template_inventory": template_inventory,
+        "creed_sections": creed_check,
+        "first_breath": first_breath_analysis,
+        "capabilities": capabilities,
+        "init_script": init_params,
+        "cross_checks": {
+            "skill_name_match": skill_name_match,
+            "template_files_match": init_template_match,
+        },
+        "findings": findings,
+        "finding_count": len(findings),
+        "critical_count": sum(1 for f in findings if f["severity"] == "critical"),
+        "high_count": sum(1 for f in findings if f["severity"] == "high"),
+    }
+
+    output_json(result, args.output)
+
+
+def output_json(data: dict, output_path: str | None) -> None:
+    """Write JSON to file or stdout."""
+    json_str = json.dumps(data, indent=2)
+    if output_path:
+        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+        Path(output_path).write_text(json_str + "\n")
+        print(f"Wrote: {output_path}", file=sys.stderr)
+    else:
+        print(json_str)
+
+
+if __name__ == "__main__":
+    main()

package/lib/bmad-cache/bmb/skills/bmad-agent-builder/scripts/prepass-structure-capabilities.py

@@ -6,11 +6,12 @@ can use instead of reading all files itself. Covers:
 - Frontmatter parsing and validation
 - Section inventory (H2/H3 headers)
 - Template artifact detection
-- Agent name validation (bmad-{code}-agent-{name} or bmad-agent-{name})
-- Required agent sections (Overview, Identity, Communication Style, Principles, On Activation)
+- Agent name validation (kebab-case, must contain 'agent')
+- Required agent sections (stateless vs memory agent bootloader detection)
 - Memory path consistency checking
 - Language/directness pattern grep
 - On Exit / Exiting section detection (invalid)
+- Capability file scanning in references/ directory
 """
 
 # /// script
@@ -44,7 +45,11 @@ TEMPLATE_ARTIFACTS = [
     r'\{if-module\}', r'\{/if-module\}',
     r'\{if-headless\}', r'\{/if-headless\}',
     r'\{if-autonomous\}', r'\{/if-autonomous\}',
-    r'\{if-sidecar\}', r'\{/if-sidecar\}',
+    r'\{if-memory\}', r'\{/if-memory\}',
+    r'\{if-memory-agent\}', r'\{/if-memory-agent\}',
+    r'\{if-stateless-agent\}', r'\{/if-stateless-agent\}',
+    r'\{if-evolvable\}', r'\{/if-evolvable\}',
+    r'\{if-pulse\}', r'\{/if-pulse\}',
     r'\{displayName\}', r'\{skillName\}',
 ]
 # Runtime variables that ARE expected (not artifacts)
@@ -113,12 +118,11 @@ def parse_frontmatter(content: str) -> tuple[dict | None, list[dict]]:
             'severity': 'high', 'category': 'frontmatter',
             'issue': f'Name "{name}" is not kebab-case',
         })
-    elif not (re.match(r'^bmad-[a-z0-9]+-agent-[a-z0-9]+(-[a-z0-9]+)*$', name)
-              or re.match(r'^bmad-agent-[a-z0-9]+(-[a-z0-9]+)*$', name)):
+    elif 'agent' not in name.split('-'):
         findings.append({
             'file': 'SKILL.md', 'line': 1,
             'severity': 'medium', 'category': 'frontmatter',
-            'issue': f'Name "{name}" does not follow bmad-{{code}}-agent-{{name}} or bmad-agent-{{name}} pattern',
+            'issue': f'Name "{name}" should contain "agent" (e.g., agent-{{name}} or {{code}}-agent-{{name}})',
         })
 
     # description check
@@ -163,21 +167,49 @@ def extract_sections(content: str) -> list[dict]:
     return sections
 
 
-def check_required_sections(sections: list[dict]) -> list[dict]:
+def detect_memory_agent(skill_path: Path, content: str) -> bool:
+    """Detect if this is a memory agent bootloader (vs stateless agent).
+
+    Memory agents have assets/ with sanctum template files and contain
+    Three Laws / Sacred Truth in their SKILL.md.
+    """
+    assets_dir = skill_path / 'assets'
+    has_templates = (
+        assets_dir.exists()
+        and any(f.name.endswith('-template.md') for f in assets_dir.iterdir() if f.is_file())
+    )
+    has_three_laws = 'First Law:' in content and 'Second Law:' in content
+    has_sacred_truth = 'Sacred Truth' in content
+    return has_templates or (has_three_laws and has_sacred_truth)
+
+
+def check_required_sections(sections: list[dict], is_memory_agent: bool) -> list[dict]:
     """Check for required and invalid sections."""
     findings = []
     h2_titles = [s['title'] for s in sections if s['level'] == 2]
 
-    required = ['Overview', 'Identity', 'Communication Style', 'Principles', 'On Activation']
-    for req in required:
-        if req not in h2_titles:
-            findings.append({
-                'file': 'SKILL.md', 'line': 1,
-                'severity': 'high', 'category': 'sections',
-                'issue': f'Missing ## {req} section',
-            })
+    if is_memory_agent:
+        # Memory agent bootloaders have a different required structure
+        required = ['The Three Laws', 'The Sacred Truth', 'On Activation']
+        for req in required:
+            if req not in h2_titles:
+                findings.append({
+                    'file': 'SKILL.md', 'line': 1,
+                    'severity': 'high', 'category': 'sections',
+                    'issue': f'Missing ## {req} section (required for memory agent bootloader)',
+                })
+    else:
+        # Stateless agents use the traditional full structure
+        required = ['Overview', 'Identity', 'Communication Style', 'Principles', 'On Activation']
+        for req in required:
+            if req not in h2_titles:
+                findings.append({
+                    'file': 'SKILL.md', 'line': 1,
+                    'severity': 'high', 'category': 'sections',
+                    'issue': f'Missing ## {req} section',
+                })
 
-    # Invalid sections
+    # Invalid sections (both types)
     for s in sections:
         if s['level'] == 2:
             for pattern, message in INVALID_SECTIONS:
@@ -218,7 +250,7 @@ def extract_memory_paths(skill_path: Path) -> tuple[list[str], list[dict]]:
     memory_paths = set()
 
     # Memory path patterns
-    mem_pattern = re.compile(r'(?:memory/|sidecar/)[\w\-/]+(?:\.\w+)?')
+    mem_pattern = re.compile(r'memory/[\w\-/]+(?:\.\w+)?')
 
     files_to_scan = []
 
@@ -226,7 +258,7 @@ def extract_memory_paths(skill_path: Path) -> tuple[list[str], list[dict]]:
     if skill_md.exists():
         files_to_scan.append(('SKILL.md', skill_md))
 
-    for subdir in ['prompts', 'resources']:
+    for subdir in ['prompts', 'resources', 'references']:
         d = skill_path / subdir
         if d.exists():
             for f in sorted(d.iterdir()):
@@ -247,7 +279,6 @@ def extract_memory_paths(skill_path: Path) -> tuple[list[str], list[dict]]:
         prefixes.add(prefix)
 
     memory_prefixes = {p for p in prefixes if 'memory' in p.lower()}
-    sidecar_prefixes = {p for p in prefixes if 'sidecar' in p.lower()}
 
     if len(memory_prefixes) > 1:
         findings.append({
@@ -256,13 +287,6 @@ def extract_memory_paths(skill_path: Path) -> tuple[list[str], list[dict]]:
             'issue': f'Inconsistent memory path prefixes: {", ".join(sorted(memory_prefixes))}',
         })
 
-    if len(sidecar_prefixes) > 1:
-        findings.append({
-            'file': 'multiple', 'line': 0,
-            'severity': 'medium', 'category': 'memory-paths',
-            'issue': f'Inconsistent sidecar path prefixes: {", ".join(sorted(sidecar_prefixes))}',
-        })
-
     return sorted_paths, findings
 
 
@@ -274,6 +298,15 @@ def check_prompt_basics(skill_path: Path) -> tuple[list[dict], list[dict]]:
 
     prompt_files = [f for f in sorted(skill_path.iterdir())
                     if f.is_file() and f.suffix == '.md' and f.name not in skip_files]
+
+    # Also scan references/ for capability prompts (memory agents keep prompts here)
+    refs_dir = skill_path / 'references'
+    if refs_dir.exists():
+        prompt_files.extend(
+            f for f in sorted(refs_dir.iterdir())
+            if f.is_file() and f.suffix == '.md'
+        )
+
     if not prompt_files:
         return prompt_details, findings
 
@@ -344,13 +377,16 @@ def scan_structure_capabilities(skill_path: Path) -> dict:
 
     skill_content = skill_md.read_text(encoding='utf-8')
 
+    # Detect agent type
+    is_memory_agent = detect_memory_agent(skill_path, skill_content)
+
     # Frontmatter
     frontmatter, fm_findings = parse_frontmatter(skill_content)
     all_findings.extend(fm_findings)
 
     # Sections
     sections = extract_sections(skill_content)
-    section_findings = check_required_sections(sections)
+    section_findings = check_required_sections(sections, is_memory_agent)
     all_findings.extend(section_findings)
 
     # Template artifacts in SKILL.md
@@ -397,6 +433,7 @@ def scan_structure_capabilities(skill_path: Path) -> dict:
         'metadata': {
             'frontmatter': frontmatter,
             'sections': sections,
+            'is_memory_agent': is_memory_agent,
         },
         'prompt_details': prompt_details,
         'memory_paths': memory_paths,