bmad-method 6.3.1-next.2 → 6.3.1-next.21

package/src/scripts/resolve_customization.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Resolve customization for a BMad skill using three-layer TOML merge.
+
+Reads customization from three layers (highest priority first):
+  1. {project-root}/_bmad/custom/{name}.user.toml  (personal, gitignored)
+  2. {project-root}/_bmad/custom/{name}.toml        (team/org, committed)
+  3. {skill-root}/customize.toml                    (skill defaults)
+
+Skill name is derived from the basename of the skill directory.
+
+Outputs merged JSON to stdout. Errors go to stderr.
+
+Requires Python 3.11+ (uses stdlib `tomllib`). No `uv`, no `pip install`,
+no virtualenv — plain `python3` is sufficient.
+
+  python3 resolve_customization.py --skill /abs/path/to/skill-dir
+  python3 resolve_customization.py --skill ... --key agent
+  python3 resolve_customization.py --skill ... --key agent.menu
+
+Merge rules (purely structural — no field-name special-casing):
+  - Scalars (string, int, bool, float): override wins
+  - Tables: deep merge (recursively apply these rules)
+  - Arrays of tables where every item shares the *same* identifier
+    field (every item has `code`, or every item has `id`):
+    merge by that key (matching keys replace, new keys append)
+  - All other arrays — including arrays where only some items have
+    `code` or `id`, or where items mix the two keys:
+    append (base items followed by override items)
+
+No removal mechanism — overrides cannot delete base items. To suppress
+a default, fork the skill or override the item by code with a no-op
+description/prompt.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:
+    sys.stderr.write(
+        "error: Python 3.11+ is required (stdlib `tomllib` not found).\n"
+        "Install a newer Python or run the resolution manually per the\n"
+        "fallback instructions in the skill's SKILL.md.\n"
+    )
+    sys.exit(3)
+
+
+_MISSING = object()
+_KEYED_MERGE_FIELDS = ("code", "id")
+
+
+def find_project_root(start: Path):
+    current = start.resolve()
+    while True:
+        if (current / "_bmad").exists() or (current / ".git").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent
+
+
+def load_toml(file_path: Path, required: bool = False) -> dict:
+    if not file_path.exists():
+        if required:
+            sys.stderr.write(f"error: required customization file not found: {file_path}\n")
+            sys.exit(1)
+        return {}
+    try:
+        with file_path.open("rb") as f:
+            parsed = tomllib.load(f)
+        if not isinstance(parsed, dict):
+            if required:
+                sys.stderr.write(f"error: {file_path} did not parse to a table\n")
+                sys.exit(1)
+            return {}
+        return parsed
+    except tomllib.TOMLDecodeError as error:
+        level = "error" if required else "warning"
+        sys.stderr.write(f"{level}: failed to parse {file_path}: {error}\n")
+        if required:
+            sys.exit(1)
+        return {}
+    except OSError as error:
+        level = "error" if required else "warning"
+        sys.stderr.write(f"{level}: failed to read {file_path}: {error}\n")
+        if required:
+            sys.exit(1)
+        return {}
+
+
+def _detect_keyed_merge_field(items):
+    """Return 'code' or 'id' if every table item carries that *same* field.
+
+    All items must share the same identifier (all `code`, or all `id`).
+    Mixed arrays — where some items use `code` and others use `id` —
+    return None and fall through to append semantics. This is intentional:
+    mixing identifier keys within one array is a schema smell, and
+    append-fallback is safer than guessing which key should merge.
+    """
+    if not items or not all(isinstance(item, dict) for item in items):
+        return None
+    for candidate in _KEYED_MERGE_FIELDS:
+        if all(item.get(candidate) is not None for item in items):
+            return candidate
+    return None
+
+
+def _merge_by_key(base, override, key_name):
+    result = []
+    index_by_key = {}
+
+    for item in base:
+        if not isinstance(item, dict):
+            continue
+        if item.get(key_name) is not None:
+            index_by_key[item[key_name]] = len(result)
+        result.append(dict(item))
+
+    for item in override:
+        if not isinstance(item, dict):
+            result.append(item)
+            continue
+        key = item.get(key_name)
+        if key is not None and key in index_by_key:
+            result[index_by_key[key]] = dict(item)
+        else:
+            if key is not None:
+                index_by_key[key] = len(result)
+            result.append(dict(item))
+
+    return result
+
+
+def _merge_arrays(base, override):
+    """Shape-aware array merge. Base + override combined tables may opt into
+    keyed merge if every item has `code` or `id`. Otherwise: append."""
+    base_arr = base if isinstance(base, list) else []
+    override_arr = override if isinstance(override, list) else []
+    keyed_field = _detect_keyed_merge_field(base_arr + override_arr)
+    if keyed_field:
+        return _merge_by_key(base_arr, override_arr, keyed_field)
+    return base_arr + override_arr
+
+
+def deep_merge(base, override):
+    """Recursively merge override into base using structural rules.
+    - Table + table: deep merge
+    - Array + array: shape-aware (keyed merge if all items have code/id, else append)
+    - Anything else: override wins
+    """
+    if isinstance(base, dict) and isinstance(override, dict):
+        result = dict(base)
+        for key, over_val in override.items():
+            if key in result:
+                result[key] = deep_merge(result[key], over_val)
+            else:
+                result[key] = over_val
+        return result
+    if isinstance(base, list) and isinstance(override, list):
+        return _merge_arrays(base, override)
+    return override
+
+
+def extract_key(data, dotted_key: str):
+    parts = dotted_key.split(".")
+    current = data
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            return _MISSING
+    return current
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Resolve customization for a BMad skill using three-layer TOML merge.",
+        add_help=True,
+    )
+    parser.add_argument(
+        "--skill", "-s", required=True,
+        help="Absolute path to the skill directory (must contain customize.toml)",
+    )
+    parser.add_argument(
+        "--key", "-k", action="append", default=[],
+        help="Dotted field path to resolve (repeatable). Omit for full dump.",
+    )
+    args = parser.parse_args()
+
+    skill_dir = Path(args.skill).resolve()
+    skill_name = skill_dir.name
+    defaults_path = skill_dir / "customize.toml"
+
+    defaults = load_toml(defaults_path, required=True)
+
+    # Prefer the project that contains this skill. Only fall back to cwd if
+    # the skill isn't inside a recognizable project tree (unusual but possible
+    # for standalone skills invoked directly). Using cwd first is unsafe when
+    # an ancestor of cwd happens to have a stray _bmad/ from another project.
+    project_root = find_project_root(skill_dir) or find_project_root(Path.cwd())
+
+    team = {}
+    user = {}
+    if project_root:
+        custom_dir = project_root / "_bmad" / "custom"
+        team = load_toml(custom_dir / f"{skill_name}.toml")
+        user = load_toml(custom_dir / f"{skill_name}.user.toml")
+
+    merged = deep_merge(defaults, team)
+    merged = deep_merge(merged, user)
+
+    if args.key:
+        output = {}
+        for key in args.key:
+            value = extract_key(merged, key)
+            if value is not _MISSING:
+                output[key] = value
+    else:
+        output = merged
+
+    sys.stdout.write(json.dumps(output, indent=2, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/tools/installer/cli-utils.js

@@ -1,20 +1,6 @@
-const path = require('node:path');
-const os = require('node:os');
 const prompts = require('./prompts');
 
 const CLIUtils = {
-  /**
-   * Get version from package.json
-   */
-  getVersion() {
-    try {
-      const packageJson = require(path.join(__dirname, '..', '..', 'package.json'));
-      return packageJson.version || 'Unknown';
-    } catch {
-      return 'Unknown';
-    }
-  },
-
   /**
    * Display BMAD logo and version using @clack intro + box
    */
@@ -52,37 +38,6 @@ const CLIUtils = {
     });
   },
 
-  /**
-   * Display section header
-   * @param {string} title - Section title
-   * @param {string} subtitle - Optional subtitle
-   */
-  async displaySection(title, subtitle = null) {
-    await prompts.note(subtitle || '', title);
-  },
-
-  /**
-   * Display info box
-   * @param {string|Array} content - Content to display
-   * @param {Object} options - Box options
-   */
-  async displayBox(content, options = {}) {
-    let text = content;
-    if (Array.isArray(content)) {
-      text = content.join('\n\n');
-    }
-
-    const color = await prompts.getColor();
-    const borderColor = options.borderColor || 'cyan';
-    const colorMap = { green: color.green, red: color.red, yellow: color.yellow, cyan: color.cyan, blue: color.blue };
-    const formatBorder = colorMap[borderColor] || color.cyan;
-
-    await prompts.box(text, options.title, {
-      rounded: options.borderStyle === 'round' || options.borderStyle === undefined,
-      formatBorder,
-    });
-  },
-
   /**
    * Display module configuration header
    * @param {string} moduleName - Module name (fallback if no custom header)
@@ -93,98 +48,6 @@ const CLIUtils = {
     const title = header || `Configuring ${moduleName.toUpperCase()} Module`;
     await prompts.note(subheader || '', title);
   },
-
-  /**
-   * Display module with no custom configuration
-   * @param {string} moduleName - Module name (fallback if no custom header)
-   * @param {string} header - Custom header from module.yaml
-   * @param {string} subheader - Custom subheader from module.yaml
-   */
-  async displayModuleNoConfig(moduleName, header = null, subheader = null) {
-    const title = header || `${moduleName.toUpperCase()} Module - No Custom Configuration`;
-    await prompts.note(subheader || '', title);
-  },
-
-  /**
-   * Display step indicator
-   * @param {number} current - Current step
-   * @param {number} total - Total steps
-   * @param {string} description - Step description
-   */
-  async displayStep(current, total, description) {
-    const progress = `[${current}/${total}]`;
-    await prompts.log.step(`${progress} ${description}`);
-  },
-
-  /**
-   * Display completion message
-   * @param {string} message - Completion message
-   */
-  async displayComplete(message) {
-    const color = await prompts.getColor();
-    await prompts.box(`\u2728 ${message}`, 'Complete', {
-      rounded: true,
-      formatBorder: color.green,
-    });
-  },
-
-  /**
-   * Display error message
-   * @param {string} message - Error message
-   */
-  async displayError(message) {
-    const color = await prompts.getColor();
-    await prompts.box(`\u2717 ${message}`, 'Error', {
-      rounded: true,
-      formatBorder: color.red,
-    });
-  },
-
-  /**
-   * Format list for display
-   * @param {Array} items - Items to display
-   * @param {string} prefix - Item prefix
-   */
-  formatList(items, prefix = '\u2022') {
-    return items.map((item) => `  ${prefix} ${item}`).join('\n');
-  },
-
-  /**
-   * Clear previous lines
-   * @param {number} lines - Number of lines to clear
-   */
-  clearLines(lines) {
-    for (let i = 0; i < lines; i++) {
-      process.stdout.moveCursor(0, -1);
-      process.stdout.clearLine(1);
-    }
-  },
-
-  /**
-   * Display module completion message
-   * @param {string} moduleName - Name of the completed module
-   * @param {boolean} clearScreen - Whether to clear the screen first (deprecated, always false now)
-   */
-  displayModuleComplete(moduleName, clearScreen = false) {
-    // No longer clear screen or show boxes - just a simple completion message
-    // This is deprecated but kept for backwards compatibility
-  },
-
-  /**
-   * Expand path with ~ expansion
-   * @param {string} inputPath - Path to expand
-   * @returns {string} Expanded path
-   */
-  expandPath(inputPath) {
-    if (!inputPath) return inputPath;
-
-    // Expand ~ to home directory
-    if (inputPath.startsWith('~')) {
-      return path.join(os.homedir(), inputPath.slice(1));
-    }
-
-    return inputPath;
-  },
 };
 
 module.exports = { CLIUtils };

package/tools/installer/commands/install.js

@@ -24,6 +24,19 @@ module.exports = {
     ['--output-folder <path>', 'Output folder path relative to project root (default: _bmad-output)'],
     ['--custom-source <sources>', 'Comma-separated Git URLs or local paths to install custom modules from'],
     ['-y, --yes', 'Accept all defaults and skip prompts where possible'],
+    [
+      '--channel <channel>',
+      'Apply channel (stable|next) to all external modules being installed. --all-stable and --all-next are aliases.',
+    ],
+    ['--all-stable', 'Alias for --channel=stable. Resolves externals to the highest stable release tag.'],
+    ['--all-next', 'Alias for --channel=next. Resolves externals to main HEAD.'],
+    ['--next <code>', 'Install module <code> from main HEAD (next channel). Repeatable.', (value, prev) => [...(prev || []), value], []],
+    [
+      '--pin <spec>',
+      'Pin module to a specific tag: --pin CODE=TAG (e.g. --pin bmb=v1.7.0). Repeatable.',
+      (value, prev) => [...(prev || []), value],
+      [],
+    ],
   ],
   action: async (options) => {
     try {

package/tools/installer/commands/status.js

@@ -19,7 +19,7 @@ module.exports = {
       const { bmadDir } = await installer.findBmadDir(projectDir);
 
       // Check if bmad directory exists
-      const fs = require('fs-extra');
+      const fs = require('../fs-native');
       if (!(await fs.pathExists(bmadDir))) {
         await prompts.log.warn('No BMAD installation found in the current directory.');
         await prompts.log.message(`Expected location: ${bmadDir}`);

package/tools/installer/commands/uninstall.js

@@ -1,5 +1,5 @@
 const path = require('node:path');
-const fs = require('fs-extra');
+const fs = require('../fs-native');
 const prompts = require('../prompts');
 const { Installer } = require('../core/installer');
 

package/tools/installer/core/config.js

@@ -3,7 +3,7 @@
  * User input comes from either UI answers or headless CLI flags.
  */
 class Config {
-  constructor({ directory, modules, ides, skipPrompts, verbose, actionType, coreConfig, moduleConfigs, quickUpdate }) {
+  constructor({ directory, modules, ides, skipPrompts, verbose, actionType, coreConfig, moduleConfigs, quickUpdate, channelOptions }) {
     this.directory = directory;
     this.modules = Object.freeze([...modules]);
     this.ides = Object.freeze([...ides]);
@@ -13,6 +13,8 @@ class Config {
     this.coreConfig = coreConfig;
     this.moduleConfigs = moduleConfigs;
     this._quickUpdate = quickUpdate;
+    // channelOptions carry a Map + Set; don't deep-freeze.
+    this.channelOptions = channelOptions || null;
     Object.freeze(this);
   }
 
@@ -37,6 +39,7 @@ class Config {
       coreConfig: userInput.coreConfig || {},
       moduleConfigs: userInput.moduleConfigs || null,
       quickUpdate: userInput._quickUpdate || false,
+      channelOptions: userInput.channelOptions || null,
     });
   }
 

package/tools/installer/core/existing-install.js

@@ -1,5 +1,5 @@
 const path = require('node:path');
-const fs = require('fs-extra');
+const fs = require('../fs-native');
 const yaml = require('yaml');
 const { Manifest } = require('./manifest');
 

package/tools/installer/core/install-paths.js

@@ -1,5 +1,5 @@
 const path = require('node:path');
-const fs = require('fs-extra');
+const fs = require('../fs-native');
 const { getProjectRoot } = require('../project-root');
 const { BMAD_FOLDER_NAME } = require('../ide/shared/path-utils');
 
@@ -19,14 +19,16 @@ class InstallPaths {
     const isUpdate = await fs.pathExists(bmadDir);
 
     const configDir = path.join(bmadDir, '_config');
-    const agentsDir = path.join(configDir, 'agents');
     const coreDir = path.join(bmadDir, 'core');
+    const scriptsDir = path.join(bmadDir, 'scripts');
+    const customDir = path.join(bmadDir, 'custom');
 
     for (const [dir, label] of [
       [bmadDir, 'bmad directory'],
       [configDir, 'config directory'],
-      [agentsDir, 'agents config directory'],
       [coreDir, 'core module directory'],
+      [scriptsDir, 'shared scripts directory'],
+      [customDir, 'customizations directory'],
     ]) {
       await ensureWritableDir(dir, label);
     }
@@ -37,8 +39,9 @@ class InstallPaths {
       projectRoot,
       bmadDir,
       configDir,
-      agentsDir,
       coreDir,
+      scriptsDir,
+      customDir,
       isUpdate,
     });
   }
@@ -51,8 +54,11 @@ class InstallPaths {
   manifestFile() {
     return path.join(this.configDir, 'manifest.yaml');
   }
-  agentManifest() {
-    return path.join(this.configDir, 'agent-manifest.csv');
+  centralConfig() {
+    return path.join(this.bmadDir, 'config.toml');
+  }
+  centralUserConfig() {
+    return path.join(this.bmadDir, 'config.user.toml');
   }
   filesManifest() {
     return path.join(this.configDir, 'files-manifest.csv');