bmad-method 6.2.3-next.3 → 6.2.3-next.30

package/src/core-skills/bmad-init/scripts/bmad_init.py

@@ -1,624 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = ["pyyaml"]
-# ///
-
-#!/usr/bin/env python3
-"""
-BMad Init — Project configuration bootstrap and config loader.
-
-Config files (flat YAML per module):
-  - _bmad/core/config.yaml (core settings — user_name, language, output_folder, etc.)
-  - _bmad/{module}/config.yaml (module settings + core values merged in)
-
-Usage:
-  # Fast path — load all vars for a module (includes core vars)
-  python bmad_init.py load --module bmb --all --project-root /path
-
-  # Load specific vars with optional defaults
-  python bmad_init.py load --module bmb --vars var1:default1,var2 --project-root /path
-
-  # Load core only
-  python bmad_init.py load --all --project-root /path
-
-  # Check if init is needed
-  python bmad_init.py check --project-root /path
-  python bmad_init.py check --module bmb --skill-path /path/to/skill --project-root /path
-
-  # Resolve module defaults given core answers
-  python bmad_init.py resolve-defaults --module bmb --core-answers '{"output_folder":"..."}' --project-root /path
-
-  # Write config from answered questions
-  python bmad_init.py write --answers '{"core": {...}, "bmb": {...}}' --project-root /path
-"""
-
-import argparse
-import json
-import os
-import sys
-from pathlib import Path
-
-import yaml
-
-
-# =============================================================================
-# Project Root Detection
-# =============================================================================
-
-def find_project_root(llm_provided=None):
-    """
-    Find project root by looking for _bmad folder.
-
-    Args:
-        llm_provided: Path explicitly provided via --project-root.
-
-    Returns:
-        Path to project root, or None if not found.
-    """
-    if llm_provided:
-        candidate = Path(llm_provided)
-        if (candidate / '_bmad').exists():
-            return candidate
-        # First run — _bmad won't exist yet but LLM path is still valid
-        if candidate.is_dir():
-            return candidate
-
-    for start_dir in [Path.cwd(), Path(__file__).resolve().parent]:
-        current_dir = start_dir
-        while current_dir != current_dir.parent:
-            if (current_dir / '_bmad').exists():
-                return current_dir
-            current_dir = current_dir.parent
-
-    return None
-
-
-# =============================================================================
-# Module YAML Loading
-# =============================================================================
-
-def load_module_yaml(path):
-    """
-    Load and parse a module.yaml file, separating metadata from variable definitions.
-
-    Returns:
-        Dict with 'meta' (code, name, etc.) and 'variables' (var definitions)
-        and 'directories' (list of dir templates), or None on failure.
-    """
-    try:
-        with open(path, 'r', encoding='utf-8') as f:
-            raw = yaml.safe_load(f)
-    except Exception:
-        return None
-
-    if not raw or not isinstance(raw, dict):
-        return None
-
-    meta_keys = {'code', 'name', 'description', 'default_selected', 'header', 'subheader'}
-    meta = {}
-    variables = {}
-    directories = []
-
-    for key, value in raw.items():
-        if key == 'directories':
-            directories = value if isinstance(value, list) else []
-        elif key in meta_keys:
-            meta[key] = value
-        elif isinstance(value, dict) and 'prompt' in value:
-            variables[key] = value
-        # Skip comment-only entries (## var_name lines become None values)
-
-    return {'meta': meta, 'variables': variables, 'directories': directories}
-
-
-def find_core_module_yaml():
-    """Find the core module.yaml bundled with this skill."""
-    return Path(__file__).resolve().parent.parent / 'resources' / 'core-module.yaml'
-
-
-def find_target_module_yaml(module_code, project_root, skill_path=None):
-    """
-    Find module.yaml for a given module code.
-
-    Search order:
-      1. skill_path/assets/module.yaml (calling skill's assets)
-      2. skill_path/module.yaml (calling skill's root)
-      3. _bmad/{module_code}/module.yaml (installed module location)
-    """
-    search_paths = []
-
-    if skill_path:
-        sp = Path(skill_path)
-        search_paths.append(sp / 'assets' / 'module.yaml')
-        search_paths.append(sp / 'module.yaml')
-
-    if project_root and module_code:
-        search_paths.append(Path(project_root) / '_bmad' / module_code / 'module.yaml')
-
-    for path in search_paths:
-        if path.exists():
-            return path
-
-    return None
-
-
-# =============================================================================
-# Config Loading (Flat per-module files)
-# =============================================================================
-
-def load_config_file(path):
-    """Load a flat YAML config file. Returns dict or None."""
-    try:
-        with open(path, 'r', encoding='utf-8') as f:
-            data = yaml.safe_load(f)
-            return data if isinstance(data, dict) else None
-    except Exception:
-        return None
-
-
-def load_module_config(module_code, project_root):
-    """Load config for a specific module from _bmad/{module}/config.yaml."""
-    config_path = Path(project_root) / '_bmad' / module_code / 'config.yaml'
-    return load_config_file(config_path)
-
-
-def resolve_project_root_placeholder(value, project_root):
-    """Replace {project-root} placeholder with actual path."""
-    if not value or not isinstance(value, str):
-        return value
-    if '{project-root}' not in value:
-        return value
-
-    # Strip the {project-root} token to inspect what remains, so we can
-    # correctly handle absolute paths stored as "{project-root}//absolute/path"
-    # (produced by the "{project-root}/{value}" template applied to an absolute value).
-    suffix = value.replace('{project-root}', '', 1)
-
-    # Strip the one path separator that follows the token (if any)
-    if suffix.startswith('/') or suffix.startswith('\\'):
-        remainder = suffix[1:]
-    else:
-        remainder = suffix
-
-    if os.path.isabs(remainder):
-        # The original value was an absolute path stored with a {project-root}/ prefix.
-        # Return the absolute path directly — no joining needed.
-        return remainder
-
-    # Relative path: join with project root and normalize to resolve any .. segments.
-    return os.path.normpath(os.path.join(str(project_root), remainder))
-
-
-def parse_var_specs(vars_string):
-    """
-    Parse variable specs: var_name:default_value,var_name2:default_value2
-    No default = returns null if missing.
-    """
-    if not vars_string:
-        return []
-    specs = []
-    for spec in vars_string.split(','):
-        spec = spec.strip()
-        if not spec:
-            continue
-        if ':' in spec:
-            parts = spec.split(':', 1)
-            specs.append({'name': parts[0].strip(), 'default': parts[1].strip()})
-        else:
-            specs.append({'name': spec, 'default': None})
-    return specs
-
-
-# =============================================================================
-# Template Expansion
-# =============================================================================
-
-def expand_template(value, context):
-    """
-    Expand {placeholder} references in a string using context dict.
-
-    Supports: {project-root}, {value}, {output_folder}, {directory_name}, etc.
-    """
-    if not value or not isinstance(value, str):
-        return value
-    result = value
-    for key, val in context.items():
-        placeholder = '{' + key + '}'
-        if placeholder in result and val is not None:
-            result = result.replace(placeholder, str(val))
-    return result
-
-
-def apply_result_template(var_def, raw_value, context):
-    """
-    Apply a variable's result template to transform the raw user answer.
-
-    E.g., result: "{project-root}/{value}" with value="_bmad-output"
-    becomes "/Users/foo/project/_bmad-output"
-    """
-    result_template = var_def.get('result')
-    if not result_template:
-        return raw_value
-
-    # If the user supplied an absolute path and the template would prefix it with
-    # "{project-root}/", skip the template entirely to avoid producing a broken path
-    # like "/my/project//absolute/path".
-    if isinstance(raw_value, str) and os.path.isabs(raw_value):
-        return raw_value
-
-    ctx = dict(context)
-    ctx['value'] = raw_value
-    result = expand_template(result_template, ctx)
-
-    # Normalize the resulting path to resolve any ".." segments (e.g. when the user
-    # entered a relative path such as "../../outside-dir").
-    if isinstance(result, str) and '{' not in result and os.path.isabs(result):
-        result = os.path.normpath(result)
-
-    return result
-
-
-# =============================================================================
-# Load Command (Fast Path)
-# =============================================================================
-
-def cmd_load(args):
-    """Load config vars — the fast path."""
-    project_root = find_project_root(llm_provided=args.project_root)
-    if not project_root:
-        print(json.dumps({'error': 'Project root not found (_bmad folder not detected)'}),
-              file=sys.stderr)
-        sys.exit(1)
-
-    module_code = args.module or 'core'
-
-    # Load the module's config (which includes core vars)
-    config = load_module_config(module_code, project_root)
-    if config is None:
-        print(json.dumps({
-            'init_required': True,
-            'missing_module': module_code,
-        }), file=sys.stderr)
-        sys.exit(1)
-
-    # Resolve {project-root} in all values
-    for key in config:
-        config[key] = resolve_project_root_placeholder(config[key], project_root)
-
-    if args.all:
-        print(json.dumps(config, indent=2))
-    else:
-        var_specs = parse_var_specs(args.vars)
-        if not var_specs:
-            print(json.dumps({'error': 'Either --vars or --all must be specified'}),
-                  file=sys.stderr)
-            sys.exit(1)
-        result = {}
-        for spec in var_specs:
-            val = config.get(spec['name'])
-            if val is not None and val != '':
-                result[spec['name']] = val
-            elif spec['default'] is not None:
-                result[spec['name']] = spec['default']
-            else:
-                result[spec['name']] = None
-        print(json.dumps(result, indent=2))
-
-
-# =============================================================================
-# Check Command
-# =============================================================================
-
-def cmd_check(args):
-    """Check if config exists and return status with module.yaml questions if needed."""
-    project_root = find_project_root(llm_provided=args.project_root)
-    if not project_root:
-        print(json.dumps({
-            'status': 'no_project',
-            'message': 'No project root found. Provide --project-root to bootstrap.',
-        }, indent=2))
-        return
-
-    project_root = Path(project_root)
-    module_code = args.module
-
-    # Check core config
-    core_config = load_module_config('core', project_root)
-    core_exists = core_config is not None
-
-    # If no module requested, just check core
-    if not module_code or module_code == 'core':
-        if core_exists:
-            print(json.dumps({'status': 'ready', 'project_root': str(project_root)}, indent=2))
-        else:
-            core_yaml_path = find_core_module_yaml()
-            core_module = load_module_yaml(core_yaml_path) if core_yaml_path.exists() else None
-            print(json.dumps({
-                'status': 'core_missing',
-                'project_root': str(project_root),
-                'core_module': core_module,
-            }, indent=2))
-        return
-
-    # Module requested — check if its config exists
-    module_config = load_module_config(module_code, project_root)
-    if module_config is not None:
-        print(json.dumps({'status': 'ready', 'project_root': str(project_root)}, indent=2))
-        return
-
-    # Module config missing — find its module.yaml for questions
-    target_yaml_path = find_target_module_yaml(
-        module_code, project_root, skill_path=args.skill_path
-    )
-    target_module = load_module_yaml(target_yaml_path) if target_yaml_path else None
-
-    result = {
-        'project_root': str(project_root),
-    }
-
-    if not core_exists:
-        result['status'] = 'core_missing'
-        core_yaml_path = find_core_module_yaml()
-        result['core_module'] = load_module_yaml(core_yaml_path) if core_yaml_path.exists() else None
-    else:
-        result['status'] = 'module_missing'
-        result['core_vars'] = core_config
-
-    result['target_module'] = target_module
-    if target_yaml_path:
-        result['target_module_yaml_path'] = str(target_yaml_path)
-
-    print(json.dumps(result, indent=2))
-
-
-# =============================================================================
-# Resolve Defaults Command
-# =============================================================================
-
-def cmd_resolve_defaults(args):
-    """Given core answers, resolve a module's variable defaults."""
-    project_root = find_project_root(llm_provided=args.project_root)
-    if not project_root:
-        print(json.dumps({'error': 'Project root not found'}), file=sys.stderr)
-        sys.exit(1)
-
-    try:
-        core_answers = json.loads(args.core_answers)
-    except json.JSONDecodeError as e:
-        print(json.dumps({'error': f'Invalid JSON in --core-answers: {e}'}),
-              file=sys.stderr)
-        sys.exit(1)
-
-    # Build context for template expansion
-    context = {
-        'project-root': str(project_root),
-        'directory_name': Path(project_root).name,
-    }
-    context.update(core_answers)
-
-    # Find and load the module's module.yaml
-    module_code = args.module
-    target_yaml_path = find_target_module_yaml(
-        module_code, project_root, skill_path=args.skill_path
-    )
-    if not target_yaml_path:
-        print(json.dumps({'error': f'No module.yaml found for module: {module_code}'}),
-              file=sys.stderr)
-        sys.exit(1)
-
-    module_def = load_module_yaml(target_yaml_path)
-    if not module_def:
-        print(json.dumps({'error': f'Failed to parse module.yaml at: {target_yaml_path}'}),
-              file=sys.stderr)
-        sys.exit(1)
-
-    # Resolve defaults in each variable
-    resolved_vars = {}
-    for var_name, var_def in module_def['variables'].items():
-        default = var_def.get('default', '')
-        resolved_default = expand_template(str(default), context)
-        resolved_vars[var_name] = dict(var_def)
-        resolved_vars[var_name]['default'] = resolved_default
-
-    result = {
-        'module_code': module_code,
-        'meta': module_def['meta'],
-        'variables': resolved_vars,
-        'directories': module_def['directories'],
-    }
-    print(json.dumps(result, indent=2))
-
-
-# =============================================================================
-# Write Command
-# =============================================================================
-
-def cmd_write(args):
-    """Write config files from answered questions."""
-    project_root = find_project_root(llm_provided=args.project_root)
-    if not project_root:
-        if args.project_root:
-            project_root = Path(args.project_root)
-        else:
-            print(json.dumps({'error': 'Project root not found and --project-root not provided'}),
-                  file=sys.stderr)
-            sys.exit(1)
-
-    project_root = Path(project_root)
-
-    try:
-        answers = json.loads(args.answers)
-    except json.JSONDecodeError as e:
-        print(json.dumps({'error': f'Invalid JSON in --answers: {e}'}),
-              file=sys.stderr)
-        sys.exit(1)
-
-    context = {
-        'project-root': str(project_root),
-        'directory_name': project_root.name,
-    }
-
-    # Load module.yaml definitions to get result templates
-    core_yaml_path = find_core_module_yaml()
-    core_def = load_module_yaml(core_yaml_path) if core_yaml_path.exists() else None
-
-    files_written = []
-    dirs_created = []
-
-    # Process core answers first (needed for module config expansion)
-    core_answers_raw = answers.get('core', {})
-    core_config = {}
-
-    if core_answers_raw and core_def:
-        for var_name, raw_value in core_answers_raw.items():
-            var_def = core_def['variables'].get(var_name, {})
-            expanded = apply_result_template(var_def, raw_value, context)
-            core_config[var_name] = expanded
-
-        # Write core config
-        core_dir = project_root / '_bmad' / 'core'
-        core_dir.mkdir(parents=True, exist_ok=True)
-        core_config_path = core_dir / 'config.yaml'
-
-        # Merge with existing if present
-        existing = load_config_file(core_config_path) or {}
-        existing.update(core_config)
-
-        _write_config_file(core_config_path, existing, 'CORE')
-        files_written.append(str(core_config_path))
-    elif core_answers_raw:
-        # No core_def available — write raw values
-        core_config = dict(core_answers_raw)
-        core_dir = project_root / '_bmad' / 'core'
-        core_dir.mkdir(parents=True, exist_ok=True)
-        core_config_path = core_dir / 'config.yaml'
-        existing = load_config_file(core_config_path) or {}
-        existing.update(core_config)
-        _write_config_file(core_config_path, existing, 'CORE')
-        files_written.append(str(core_config_path))
-
-    # Update context with resolved core values for module expansion
-    context.update(core_config)
-
-    # Process module answers
-    for module_code, module_answers_raw in answers.items():
-        if module_code == 'core':
-            continue
-
-        # Find module.yaml for result templates
-        target_yaml_path = find_target_module_yaml(
-            module_code, project_root, skill_path=args.skill_path
-        )
-        module_def = load_module_yaml(target_yaml_path) if target_yaml_path else None
-
-        # Build module config: start with core values, then add module values
-        # Re-read core config to get the latest (may have been updated above)
-        latest_core = load_module_config('core', project_root) or core_config
-        module_config = dict(latest_core)
-
-        for var_name, raw_value in module_answers_raw.items():
-            if module_def:
-                var_def = module_def['variables'].get(var_name, {})
-                expanded = apply_result_template(var_def, raw_value, context)
-            else:
-                expanded = raw_value
-            module_config[var_name] = expanded
-            context[var_name] = expanded  # Available for subsequent template expansion
-
-        # Write module config
-        module_dir = project_root / '_bmad' / module_code
-        module_dir.mkdir(parents=True, exist_ok=True)
-        module_config_path = module_dir / 'config.yaml'
-
-        existing = load_config_file(module_config_path) or {}
-        existing.update(module_config)
-
-        module_name = module_def['meta'].get('name', module_code.upper()) if module_def else module_code.upper()
-        _write_config_file(module_config_path, existing, module_name)
-        files_written.append(str(module_config_path))
-
-        # Create directories declared in module.yaml
-        if module_def and module_def.get('directories'):
-            for dir_template in module_def['directories']:
-                dir_path = expand_template(dir_template, context)
-                if dir_path:
-                    Path(dir_path).mkdir(parents=True, exist_ok=True)
-                    dirs_created.append(dir_path)
-
-    result = {
-        'status': 'written',
-        'files_written': files_written,
-        'dirs_created': dirs_created,
-    }
-    print(json.dumps(result, indent=2))
-
-
-def _write_config_file(path, data, module_label):
-    """Write a config YAML file with a header comment."""
-    from datetime import datetime, timezone
-    with open(path, 'w', encoding='utf-8') as f:
-        f.write(f'# {module_label} Module Configuration\n')
-        f.write(f'# Generated by bmad-init\n')
-        f.write(f'# Date: {datetime.now(timezone.utc).isoformat()}\n\n')
-        yaml.safe_dump(data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
-
-
-# =============================================================================
-# CLI Entry Point
-# =============================================================================
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='BMad Init — Project configuration bootstrap and config loader.'
-    )
-    subparsers = parser.add_subparsers(dest='command')
-
-    # --- load ---
-    load_parser = subparsers.add_parser('load', help='Load config vars (fast path)')
-    load_parser.add_argument('--module', help='Module code (omit for core only)')
-    load_parser.add_argument('--vars', help='Comma-separated vars with optional defaults')
-    load_parser.add_argument('--all', action='store_true', help='Return all config vars')
-    load_parser.add_argument('--project-root', help='Project root path')
-
-    # --- check ---
-    check_parser = subparsers.add_parser('check', help='Check if init is needed')
-    check_parser.add_argument('--module', help='Module code to check (optional)')
-    check_parser.add_argument('--skill-path', help='Path to the calling skill folder')
-    check_parser.add_argument('--project-root', help='Project root path')
-
-    # --- resolve-defaults ---
-    resolve_parser = subparsers.add_parser('resolve-defaults',
-                                           help='Resolve module defaults given core answers')
-    resolve_parser.add_argument('--module', required=True, help='Module code')
-    resolve_parser.add_argument('--core-answers', required=True, help='JSON string of core answers')
-    resolve_parser.add_argument('--skill-path', help='Path to calling skill folder')
-    resolve_parser.add_argument('--project-root', help='Project root path')
-
-    # --- write ---
-    write_parser = subparsers.add_parser('write', help='Write config files')
-    write_parser.add_argument('--answers', required=True, help='JSON string of all answers')
-    write_parser.add_argument('--skill-path', help='Path to calling skill (for module.yaml lookup)')
-    write_parser.add_argument('--project-root', help='Project root path')
-
-    args = parser.parse_args()
-    if args.command is None:
-        parser.print_help()
-        sys.exit(1)
-
-    commands = {
-        'load': cmd_load,
-        'check': cmd_check,
-        'resolve-defaults': cmd_resolve_defaults,
-        'write': cmd_write,
-    }
-
-    handler = commands.get(args.command)
-    if handler:
-        handler(args)
-    else:
-        parser.print_help()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()