ma-agents 2.22.2 → 3.0.1

package/lib/bmad-cache/bmb/{src/skills → skills}/bmad-agent-builder/scripts/prepass-prompt-metrics.py

@@ -14,7 +14,6 @@ Covers:
 - Config header and progression condition presence per prompt
 - File-level token estimates (chars / 4 rough approximation)
 - Prompt frontmatter validation (name, description, menu-code)
-- Manifest alignment check (frontmatter vs bmad-manifest.json entries)
 - Wall-of-text detection
 - Suggestive loading grep
 """
@@ -197,69 +196,6 @@ def parse_prompt_frontmatter(filepath: Path) -> dict:
     return result
 
 
-def check_manifest_alignment(skill_path: Path, prompt_frontmatters: dict[str, dict]) -> dict:
-    """Compare prompt frontmatter against bmad-manifest.json entries."""
-    alignment = {
-        'manifest_found': False,
-        'mismatches': [],
-        'manifest_only': [],
-        'prompt_only': [],
-    }
-
-    manifest_path = skill_path / 'bmad-manifest.json'
-    if not manifest_path.exists():
-        return alignment
-
-    try:
-        data = json.loads(manifest_path.read_text(encoding='utf-8'))
-    except (json.JSONDecodeError, OSError):
-        return alignment
-
-    alignment['manifest_found'] = True
-
-    capabilities = data.get('capabilities', [])
-    if not isinstance(capabilities, list):
-        return alignment
-
-    # Build manifest lookup by name
-    manifest_caps = {}
-    for cap in capabilities:
-        if isinstance(cap, dict) and cap.get('name'):
-            manifest_caps[cap['name']] = cap
-
-    # Compare
-    prompt_names = set(prompt_frontmatters.keys())
-    manifest_names = set(manifest_caps.keys())
-
-    alignment['manifest_only'] = sorted(manifest_names - prompt_names)
-    alignment['prompt_only'] = sorted(prompt_names - manifest_names)
-
-    # Check field mismatches for overlapping entries
-    for name in sorted(prompt_names & manifest_names):
-        pfm = prompt_frontmatters[name]
-        mcap = manifest_caps[name]
-
-        issues = []
-        # Compare name field
-        pfm_name = pfm.get('fields', {}).get('name')
-        if pfm_name and pfm_name != mcap.get('name'):
-            issues.append(f'name mismatch: frontmatter="{pfm_name}" manifest="{mcap.get("name")}"')
-
-        # Compare menu-code
-        pfm_mc = pfm.get('fields', {}).get('menu-code')
-        mcap_mc = mcap.get('menu-code')
-        if pfm_mc and mcap_mc and pfm_mc != mcap_mc:
-            issues.append(f'menu-code mismatch: frontmatter="{pfm_mc}" manifest="{mcap_mc}"')
-
-        if issues:
-            alignment['mismatches'].append({
-                'name': name,
-                'issues': issues,
-            })
-
-    return alignment
-
-
 def scan_file_patterns(filepath: Path, rel_path: str) -> dict:
     """Extract metrics and pattern matches from a single file."""
     content = filepath.read_text(encoding='utf-8')
@@ -357,9 +293,8 @@ def scan_prompt_metrics(skill_path: Path) -> dict:
         data['is_skill_md'] = True
         files_data.append(data)
 
-    # Prompt files at skill root — also extract frontmatter
-    prompt_frontmatters: dict[str, dict] = {}
-    skip_files = {'SKILL.md', 'bmad-manifest.json', 'bmad-skill-manifest.yaml'}
+    # Prompt files at skill root
+    skip_files = {'SKILL.md'}
 
     for f in sorted(skill_path.iterdir()):
         if f.is_file() and f.suffix == '.md' and f.name not in skip_files and f.name != 'SKILL.md':
@@ -370,10 +305,6 @@ def scan_prompt_metrics(skill_path: Path) -> dict:
             pfm = parse_prompt_frontmatter(f)
             data['prompt_frontmatter'] = pfm
 
-            # Use stem as key for manifest alignment
-            prompt_name = pfm.get('fields', {}).get('name', f.stem)
-            prompt_frontmatters[prompt_name] = pfm
-
             files_data.append(data)
 
     # Resources (just sizes, for progressive disclosure assessment)
@@ -388,9 +319,6 @@ def scan_prompt_metrics(skill_path: Path) -> dict:
                     'tokens': len(content) // 4,
                 }
 
-    # Manifest alignment
-    manifest_alignment = check_manifest_alignment(skill_path, prompt_frontmatters)
-
     # Aggregate stats
     total_waste = sum(len(f['waste_patterns']) for f in files_data)
     total_backrefs = sum(len(f['back_references']) for f in files_data)
@@ -434,7 +362,6 @@ def scan_prompt_metrics(skill_path: Path) -> dict:
             'total_wall_of_text': total_walls,
         },
         'resource_sizes': resource_sizes,
-        'manifest_alignment': manifest_alignment,
         'files': files_data,
     }
 

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

@@ -8,8 +8,6 @@ can use instead of reading all files itself. Covers:
 - Template artifact detection
 - Agent name validation (bmad-{code}-agent-{name} or bmad-agent-{name})
 - Required agent sections (Overview, Identity, Communication Style, Principles, On Activation)
-- bmad-manifest.json validation (persona field for agent detection, capabilities)
-- Capability cross-referencing with prompt files at skill root
 - Memory path consistency checking
 - Language/directness pattern grep
 - On Exit / Exiting section detection (invalid)
@@ -214,190 +212,13 @@ def find_template_artifacts(filepath: Path, rel_path: str) -> list[dict]:
     return findings
 
 
-def validate_manifest(skill_path: Path) -> tuple[dict, list[dict]]:
-    """Validate bmad-manifest.json for agent requirements."""
-    findings = []
-    validation = {
-        'found': False,
-        'valid_json': False,
-        'is_agent': False,
-        'has_capabilities': False,
-        'capability_count': 0,
-        'menu_codes': [],
-        'duplicate_menu_codes': [],
-        'capability_issues': [],
-    }
-
-    manifest_path = skill_path / 'bmad-manifest.json'
-    if not manifest_path.exists():
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'high', 'category': 'manifest',
-            'issue': 'bmad-manifest.json not found at skill root',
-        })
-        return validation, findings
-
-    validation['found'] = True
-
-    try:
-        data = json.loads(manifest_path.read_text(encoding='utf-8'))
-    except json.JSONDecodeError as e:
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'critical', 'category': 'manifest',
-            'issue': f'Invalid JSON in bmad-manifest.json: {e}',
-        })
-        return validation, findings
-
-    validation['valid_json'] = True
-
-    # Check if this is an agent (agents have a persona field)
-    has_persona = 'persona' in data
-    validation['is_agent'] = has_persona
-    if not has_persona:
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'high', 'category': 'manifest',
-            'issue': 'Missing "persona" field — agents are identified by having a persona field',
-        })
-
-    # Check capabilities
-    capabilities = data.get('capabilities')
-    if capabilities is None:
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'high', 'category': 'manifest',
-            'issue': 'Missing "capabilities" field',
-        })
-        return validation, findings
-
-    if not isinstance(capabilities, list):
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'high', 'category': 'manifest',
-            'issue': '"capabilities" is not an array',
-        })
-        return validation, findings
-
-    validation['has_capabilities'] = True
-    validation['capability_count'] = len(capabilities)
-
-    # Check each capability for required fields and unique menu codes
-    required_fields = {'name', 'menu-code', 'description'}
-    menu_codes = []
-
-    for i, cap in enumerate(capabilities):
-        if not isinstance(cap, dict):
-            findings.append({
-                'file': 'bmad-manifest.json', 'line': 0,
-                'severity': 'high', 'category': 'manifest',
-                'issue': f'Capability at index {i} is not an object',
-            })
-            continue
-
-        missing = required_fields - set(cap.keys())
-        if missing:
-            cap_name = cap.get('name', f'index-{i}')
-            findings.append({
-                'file': 'bmad-manifest.json', 'line': 0,
-                'severity': 'high', 'category': 'manifest',
-                'issue': f'Capability "{cap_name}" missing required fields: {", ".join(sorted(missing))}',
-            })
-
-        mc = cap.get('menu-code')
-        if mc:
-            menu_codes.append(mc)
-
-    validation['menu_codes'] = menu_codes
-
-    # Check for duplicate menu codes
-    seen = set()
-    dupes = set()
-    for mc in menu_codes:
-        if mc in seen:
-            dupes.add(mc)
-        seen.add(mc)
-
-    if dupes:
-        validation['duplicate_menu_codes'] = sorted(dupes)
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'high', 'category': 'manifest',
-            'issue': f'Duplicate menu codes: {", ".join(sorted(dupes))}',
-        })
-
-    return validation, findings
-
-
-def cross_reference_capabilities(skill_path: Path) -> tuple[dict, list[dict]]:
-    """Cross-reference manifest capabilities with prompt files."""
-    findings = []
-    crossref = {
-        'manifest_prompt_caps': [],
-        'missing_prompt_files': [],
-        'orphaned_prompt_files': [],
-    }
-
-    manifest_path = skill_path / 'bmad-manifest.json'
-
-    if not manifest_path.exists():
-        return crossref, findings
-
-    try:
-        data = json.loads(manifest_path.read_text(encoding='utf-8'))
-    except (json.JSONDecodeError, OSError):
-        return crossref, findings
-
-    capabilities = data.get('capabilities', [])
-    if not isinstance(capabilities, list):
-        return crossref, findings
-
-    # Get prompt-type capabilities from manifest
-    prompt_cap_names = set()
-    for cap in capabilities:
-        if isinstance(cap, dict) and cap.get('type') == 'prompt':
-            name = cap.get('name')
-            if name:
-                prompt_cap_names.add(name)
-                crossref['manifest_prompt_caps'].append(name)
-
-    # Get actual prompt files (at skill root, excluding SKILL.md and non-prompt files)
-    actual_prompts = set()
-    skip_files = {'SKILL.md', 'bmad-manifest.json', 'bmad-skill-manifest.yaml'}
-    for f in skill_path.iterdir():
-        if f.is_file() and f.suffix == '.md' and f.name not in skip_files:
-                actual_prompts.add(f.stem)
-
-    # Missing prompt files (in manifest but no file)
-    missing = prompt_cap_names - actual_prompts
-    for name in sorted(missing):
-        crossref['missing_prompt_files'].append(name)
-        findings.append({
-            'file': 'bmad-manifest.json', 'line': 0,
-            'severity': 'high', 'category': 'capability-crossref',
-            'issue': f'Prompt capability "{name}" has no matching file {name}.md at skill root',
-        })
-
-    # Orphaned prompt files (file exists but not in manifest)
-    orphaned = actual_prompts - prompt_cap_names
-    for name in sorted(orphaned):
-        crossref['orphaned_prompt_files'].append(name)
-        findings.append({
-            'file': f'{name}.md', 'line': 0,
-            'severity': 'medium', 'category': 'capability-crossref',
-            'issue': f'Prompt file {name}.md not referenced as a prompt capability in manifest',
-        })
-
-    return crossref, findings
-
-
 def extract_memory_paths(skill_path: Path) -> tuple[list[str], list[dict]]:
     """Extract all memory path references across files and check consistency."""
     findings = []
     memory_paths = set()
 
     # Memory path patterns
-    mem_pattern = re.compile(r'(?:memory/|sidecar/|\.memory/|\.sidecar/)[\w\-/]+(?:\.\w+)?')
+    mem_pattern = re.compile(r'(?:memory/|sidecar/)[\w\-/]+(?:\.\w+)?')
 
     files_to_scan = []
 
@@ -419,7 +240,7 @@ def extract_memory_paths(skill_path: Path) -> tuple[list[str], list[dict]]:
 
     sorted_paths = sorted(memory_paths)
 
-    # Check for inconsistent formats (e.g., mixing memory/ and .memory/)
+    # Check for inconsistent formats
     prefixes = set()
     for p in sorted_paths:
         prefix = p.split('/')[0]
@@ -449,7 +270,7 @@ def check_prompt_basics(skill_path: Path) -> tuple[list[dict], list[dict]]:
     """Check each prompt file for config header and progression conditions."""
     findings = []
     prompt_details = []
-    skip_files = {'SKILL.md', 'bmad-manifest.json', 'bmad-skill-manifest.yaml'}
+    skip_files = {'SKILL.md'}
 
     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]
@@ -545,15 +366,6 @@ def scan_structure_capabilities(skill_path: Path) -> dict:
                 'issue': message,
             })
 
-    # Manifest validation
-    manifest_validation, manifest_findings = validate_manifest(skill_path)
-    all_findings.extend(manifest_findings)
-    has_manifest = manifest_validation['found']
-
-    # Capability cross-reference
-    capability_crossref, crossref_findings = cross_reference_capabilities(skill_path)
-    all_findings.extend(crossref_findings)
-
     # Memory path consistency
     memory_paths, memory_findings = extract_memory_paths(skill_path)
     all_findings.extend(memory_findings)
@@ -585,9 +397,6 @@ def scan_structure_capabilities(skill_path: Path) -> dict:
         'metadata': {
             'frontmatter': frontmatter,
             'sections': sections,
-            'has_manifest': has_manifest,
-            'manifest_validation': manifest_validation,
-            'capability_crossref': capability_crossref,
         },
         'prompt_details': prompt_details,
         'memory_paths': memory_paths,

package/lib/bmad-cache/bmb/{src/skills → skills}/bmad-agent-builder/scripts/scan-path-standards.py

@@ -5,9 +5,12 @@ Validates all .md and .json files against BMad path conventions:
 1. {project-root} only valid before /_bmad
 2. Bare _bmad references must have {project-root} prefix
 3. Config variables used directly (no double-prefix)
-4. No ./ or ../ relative prefixes
-5. No absolute paths
-6. Memory paths must use {project-root}/_bmad/_memory/{skillName}-sidecar/
+4. Skill-internal paths must use ./ prefix (references/, scripts/, assets/)
+5. No ../ parent directory references
+6. No absolute paths
+7. Memory paths must use {project-root}/_bmad/memory/{skillName}-sidecar/
+8. Frontmatter allows only name and description
+9. No .md files at skill root except SKILL.md
 """
 
 # /// script
@@ -33,17 +36,22 @@ BARE_BMAD_RE = re.compile(r'(?<!\{project-root\}/)_bmad[/\s]')
 # Absolute paths
 ABSOLUTE_PATH_RE = re.compile(r'(?:^|[\s"`\'(])(/(?:Users|home|opt|var|tmp|etc|usr)/\S+)', re.MULTILINE)
 HOME_PATH_RE = re.compile(r'(?:^|[\s"`\'(])(~/\S+)', re.MULTILINE)
-# Relative prefixes
+# Parent directory reference (still invalid)
 RELATIVE_DOT_RE = re.compile(r'(?:^|[\s"`\'(])(\.\./\S+)', re.MULTILINE)
-RELATIVE_DOTSLASH_RE = re.compile(r'(?:^|[\s"`\'(])(\./\S+)', re.MULTILINE)
+# Bare skill-internal paths without ./ prefix
+# Match references/, scripts/, assets/ when NOT preceded by ./
+BARE_INTERNAL_RE = re.compile(r'(?:^|[\s"`\'(])(?<!\./)((?:references|scripts|assets)/\S+)', re.MULTILINE)
 
-# Memory path pattern: should use {project-root}/_bmad/_memory/
-MEMORY_PATH_RE = re.compile(r'_bmad/_memory/\S+')
-VALID_MEMORY_PATH_RE = re.compile(r'\{project-root\}/_bmad/_memory/\S+-sidecar/')
+# Memory path pattern: should use {project-root}/_bmad/memory/
+MEMORY_PATH_RE = re.compile(r'_bmad/memory/\S+')
+VALID_MEMORY_PATH_RE = re.compile(r'\{project-root\}/_bmad/memory/\S+-sidecar/')
 
 # Fenced code block detection (to skip examples showing wrong patterns)
 FENCE_RE = re.compile(r'^```', re.MULTILINE)
 
+# Valid frontmatter keys
+VALID_FRONTMATTER_KEYS = {'name', 'description'}
+
 
 def is_in_fenced_block(content: str, pos: int) -> bool:
     """Check if a position is inside a fenced code block."""
@@ -57,6 +65,76 @@ def get_line_number(content: str, pos: int) -> int:
     return content[:pos].count('\n') + 1
 
 
+def check_frontmatter(content: str, filepath: Path) -> list[dict]:
+    """Validate SKILL.md frontmatter contains only allowed keys."""
+    findings = []
+    if filepath.name != 'SKILL.md':
+        return findings
+
+    if not content.startswith('---'):
+        findings.append({
+            'file': filepath.name,
+            'line': 1,
+            'severity': 'critical',
+            'category': 'frontmatter',
+            'title': 'SKILL.md missing frontmatter block',
+            'detail': 'SKILL.md must start with --- frontmatter containing name and description',
+            'action': 'Add frontmatter with name and description fields',
+        })
+        return findings
+
+    # Find closing ---
+    end = content.find('\n---', 3)
+    if end == -1:
+        findings.append({
+            'file': filepath.name,
+            'line': 1,
+            'severity': 'critical',
+            'category': 'frontmatter',
+            'title': 'SKILL.md frontmatter block not closed',
+            'detail': 'Missing closing --- for frontmatter',
+            'action': 'Add closing --- after frontmatter fields',
+        })
+        return findings
+
+    frontmatter = content[4:end]
+    for i, line in enumerate(frontmatter.split('\n'), start=2):
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        if ':' in line:
+            key = line.split(':', 1)[0].strip()
+            if key not in VALID_FRONTMATTER_KEYS:
+                findings.append({
+                    'file': filepath.name,
+                    'line': i,
+                    'severity': 'high',
+                    'category': 'frontmatter',
+                    'title': f'Invalid frontmatter key: {key}',
+                    'detail': f'Only {", ".join(sorted(VALID_FRONTMATTER_KEYS))} are allowed in frontmatter',
+                    'action': f'Remove {key} from frontmatter — use as content field in SKILL.md body instead',
+                })
+
+    return findings
+
+
+def check_root_md_files(skill_path: Path) -> list[dict]:
+    """Check that no .md files exist at skill root except SKILL.md."""
+    findings = []
+    for md_file in skill_path.glob('*.md'):
+        if md_file.name != 'SKILL.md':
+            findings.append({
+                'file': md_file.name,
+                'line': 0,
+                'severity': 'high',
+                'category': 'structure',
+                'title': f'Prompt file at skill root: {md_file.name}',
+                'detail': 'All progressive disclosure content must be in ./references/ — only SKILL.md belongs at root',
+                'action': f'Move {md_file.name} to references/{md_file.name}',
+            })
+    return findings
+
+
 def scan_file(filepath: Path, skip_fenced: bool = True) -> list[dict]:
     """Scan a single file for path standard violations."""
     findings = []
@@ -70,10 +148,10 @@ def scan_file(filepath: Path, skip_fenced: bool = True) -> list[dict]:
          'Absolute path found — not portable across machines'),
         (HOME_PATH_RE, 'absolute-path', 'high',
          'Home directory path (~/) found — environment-specific'),
-        (RELATIVE_DOT_RE, 'relative-prefix', 'medium',
+        (RELATIVE_DOT_RE, 'relative-prefix', 'high',
          'Parent directory reference (../) found — fragile, breaks with reorganization'),
-        (RELATIVE_DOTSLASH_RE, 'relative-prefix', 'medium',
-         'Relative prefix (./) found — breaks when execution directory changes'),
+        (BARE_INTERNAL_RE, 'bare-internal-path', 'high',
+         'Bare skill-internal path without ./ prefix — use ./references/, ./scripts/, ./assets/ to distinguish from {project-root} paths'),
     ]
 
     for pattern, category, severity, message in checks:
@@ -99,9 +177,6 @@ def scan_file(filepath: Path, skip_fenced: bool = True) -> list[dict]:
         pos = match.start()
         if skip_fenced and is_in_fenced_block(content, pos):
             continue
-        # Check that this isn't part of {project-root}/_bmad
-        # The negative lookbehind handles this, but double-check
-        # the broader context
         start = max(0, pos - 30)
         before = content[start:pos]
         if '{project-root}/' in before:
@@ -118,12 +193,11 @@ def scan_file(filepath: Path, skip_fenced: bool = True) -> list[dict]:
             'action': '',
         })
 
-    # Memory path check — memory paths should use {project-root}/_bmad/_memory/{skillName}-sidecar/
+    # Memory path check — memory paths should use {project-root}/_bmad/memory/{skillName}-sidecar/
     for match in MEMORY_PATH_RE.finditer(content):
         pos = match.start()
         if skip_fenced and is_in_fenced_block(content, pos):
             continue
-        # Check if properly prefixed
         start = max(0, pos - 20)
         before = content[start:pos]
         matched_text = match.group()
@@ -135,7 +209,7 @@ def scan_file(filepath: Path, skip_fenced: bool = True) -> list[dict]:
                 'line': line_num,
                 'severity': 'high',
                 'category': 'memory-path',
-                'title': 'Memory path missing {project-root} prefix — use {project-root}/_bmad/_memory/',
+                'title': 'Memory path missing {project-root} prefix — use {project-root}/_bmad/memory/',
                 'detail': line_content[:120],
                 'action': '',
             })
@@ -159,6 +233,15 @@ def scan_skill(skill_path: Path, skip_fenced: bool = True) -> dict:
     """Scan all .md and .json files in a skill directory."""
     all_findings = []
 
+    # Check for .md files at root that aren't SKILL.md
+    all_findings.extend(check_root_md_files(skill_path))
+
+    # Check SKILL.md frontmatter
+    skill_md = skill_path / 'SKILL.md'
+    if skill_md.exists():
+        content = skill_md.read_text(encoding='utf-8')
+        all_findings.extend(check_frontmatter(content, skill_md))
+
     # Find all .md and .json files
     md_files = sorted(list(skill_path.rglob('*.md')) + list(skill_path.rglob('*.json')))
     if not md_files:
@@ -181,7 +264,10 @@ def scan_skill(skill_path: Path, skip_fenced: bool = True) -> dict:
         'double_prefix': 0,
         'absolute_path': 0,
         'relative_prefix': 0,
+        'bare_internal_path': 0,
         'memory_path': 0,
+        'frontmatter': 0,
+        'structure': 0,
     }
 
     for f in all_findings:
@@ -195,7 +281,7 @@ def scan_skill(skill_path: Path, skip_fenced: bool = True) -> dict:
     return {
         'scanner': 'path-standards',
         'script': 'scan-path-standards.py',
-        'version': '1.0.0',
+        'version': '2.0.0',
         'skill_path': str(skill_path),
         'timestamp': datetime.now(timezone.utc).isoformat(),
         'files_scanned': files_scanned,

package/lib/bmad-cache/bmb/skills/bmad-builder-setup/assets/module-help.csv

@@ -0,0 +1,6 @@
+module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs
+BMad Builder,bmad-builder-setup,Setup Builder Module,SB,"Install or update BMad Builder module config and help entries. Collects user preferences, writes config.yaml, and migrates legacy configs.",configure,,anytime,,,false,{project-root}/_bmad,config.yaml and config.user.yaml
+BMad Builder,bmad-agent-builder,Build an Agent,BA,"Create, edit, convert, or fix an agent skill.",build-process,"[-H] [description | path]",anytime,,bmad-agent-builder:quality-optimizer,false,output_folder,agent skill
+BMad Builder,bmad-agent-builder,Optimize an Agent,OA,Validate and optimize an existing agent skill. Produces a quality report.,quality-optimizer,[-H] [path],anytime,bmad-agent-builder:build-process,,false,bmad_builder_reports,quality report
+BMad Builder,bmad-workflow-builder,Build a Workflow,BW,"Create, edit, convert, or fix a workflow or utility skill.",build-process,"[-H] [description | path]",anytime,,bmad-workflow-builder:quality-optimizer,false,output_folder,workflow skill
+BMad Builder,bmad-workflow-builder,Optimize a Workflow,OW,Validate and optimize an existing workflow or utility skill. Produces a quality report.,quality-optimizer,[-H] [path],anytime,bmad-workflow-builder:build-process,,false,bmad_builder_reports,quality report

package/lib/bmad-cache/bmb/skills/bmad-builder-setup/assets/module.yaml

@@ -0,0 +1,20 @@
+code: bmb
+name: "BMad Builder"
+description: "Standard Skill Compliant Factory for BMad Agents, Workflows and Modules"
+module_version: 1.0.0
+default_selected: false
+module_greeting: >
+  Enjoy making your dream creations with the BMad Builder Module!
+  Run this again at any time if you want to reconfigure a setting or have updated the module, (or optionally just update _bmad/config.yaml and config.user.yaml to change existing values)
+
+  For questions, suggestions and support - check us on Discord at https://discord.gg/gk8jAdXWmj
+
+bmad_builder_output_folder:
+  prompt: "Where should your custom output (agent, workflow, module config) be saved?"
+  default: "{project-root}/skills"
+  result: "{project-root}/{value}"
+
+bmad_builder_reports:
+  prompt: "Output for Evals, Test, Quality and Planning Reports?"
+  default: "{project-root}/skills/reports"
+  result: "{project-root}/{value}"