wizz-method 1.0.1 → 1.0.3

package/tools/installer/modules/official-modules.js

@@ -7,6 +7,18 @@ const { CLIUtils } = require('../cli-utils');
 const { ExternalModuleManager } = require('./external-manager');
 
 class OfficialModules {
+  /**
+   * A config field is "missing a default" only when it has no default value at
+   * all (undefined/null). An explicit empty string (`default: ""`) is a real
+   * default meaning "defaults to blank" — it must NOT force a required prompt.
+   * Centralized so the express/customize/skip-prompts paths stay consistent.
+   * @param {*} defaultValue - The field's `default` value from module.yaml.
+   * @returns {boolean} True when the field has no usable default.
+   */
+  static isMissingDefault(defaultValue) {
+    return defaultValue === undefined || defaultValue === null;
+  }
+
   constructor(options = {}) {
     this.externalModuleManager = new ExternalModuleManager();
     // Config collection state (merged from ConfigCollector)
@@ -252,27 +264,27 @@ class OfficialModules {
   /**
    * Install a module
    * @param {string} moduleName - Code of the module to install (from module.yaml)
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    * @param {Function} fileTrackingCallback - Optional callback to track installed files
    * @param {Object} options - Additional installation options
    * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
    * @param {Object} options.moduleConfig - Module configuration from config collector
    * @param {Object} options.logger - Logger instance for output
    */
-  async install(moduleName, bmadDir, fileTrackingCallback = null, options = {}) {
+  async install(moduleName, wizzDir, fileTrackingCallback = null, options = {}) {
     // Check if this module has a plugin resolution (custom marketplace install)
     const { CustomModuleManager } = require('./custom-module-manager');
     const customMgr = new CustomModuleManager();
     const resolved = customMgr.getResolution(moduleName);
     if (resolved) {
-      return this.installFromResolution(resolved, bmadDir, fileTrackingCallback, options);
+      return this.installFromResolution(resolved, wizzDir, fileTrackingCallback, options);
     }
 
     const sourcePath = await this.findModuleSource(moduleName, {
       silent: options.silent,
       channelOptions: options.channelOptions,
     });
-    const targetPath = path.join(bmadDir, moduleName);
+    const targetPath = path.join(wizzDir, moduleName);
 
     if (!sourcePath) {
       throw new Error(
@@ -287,18 +299,18 @@ class OfficialModules {
     await this.copyModuleWithFiltering(sourcePath, targetPath, fileTrackingCallback, options.moduleConfig);
 
     if (!options.skipModuleInstaller) {
-      await this.createModuleDirectories(moduleName, bmadDir, options);
+      await this.createModuleDirectories(moduleName, wizzDir, options);
     }
 
     const { Manifest } = require('../core/manifest');
     const manifestObj = new Manifest();
-    const versionInfo = await manifestObj.getModuleVersionInfo(moduleName, bmadDir, sourcePath);
+    const versionInfo = await manifestObj.getModuleVersionInfo(moduleName, wizzDir, sourcePath);
 
     // Pick up channel resolution recorded by the external manager (the only
     // manager that does pre-clone resolution now that community is retired).
     const resolution = this.externalModuleManager.getResolution(moduleName);
 
-    await manifestObj.addModule(bmadDir, moduleName, {
+    await manifestObj.addModule(wizzDir, moduleName, {
       version: resolution?.version || versionInfo.version,
       source: versionInfo.source,
       npmPackage: versionInfo.npmPackage,
@@ -314,12 +326,12 @@ class OfficialModules {
    * Install a module from a PluginResolver resolution result.
    * Copies specific skill directories and places module-help.csv at the target root.
    * @param {Object} resolved - ResolvedModule from PluginResolver
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    * @param {Function} fileTrackingCallback - Optional callback to track installed files
    * @param {Object} options - Installation options
    */
-  async installFromResolution(resolved, bmadDir, fileTrackingCallback = null, options = {}) {
-    const targetPath = path.join(bmadDir, resolved.code);
+  async installFromResolution(resolved, wizzDir, fileTrackingCallback = null, options = {}) {
+    const targetPath = path.join(wizzDir, resolved.code);
 
     if (await fs.pathExists(targetPath)) {
       await fs.remove(targetPath);
@@ -349,7 +361,7 @@ class OfficialModules {
 
     // Create directories declared in module.yaml (strategies 1-4 may have these)
     if (!options.skipModuleInstaller) {
-      await this.createModuleDirectories(resolved.code, bmadDir, options);
+      await this.createModuleDirectories(resolved.code, wizzDir, options);
     }
 
     // Update manifest. For custom-source installs we derive channel from the
@@ -370,7 +382,7 @@ class OfficialModules {
       if (resolved.rawInput) manifestEntry.rawSource = resolved.rawInput;
     }
     if (resolved.localPath) manifestEntry.localPath = resolved.localPath;
-    await manifestObj.addModule(bmadDir, resolved.code, manifestEntry);
+    await manifestObj.addModule(wizzDir, resolved.code, manifestEntry);
 
     return {
       success: true,
@@ -388,11 +400,11 @@ class OfficialModules {
   /**
    * Update an existing module
    * @param {string} moduleName - Name of the module to update
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    */
-  async update(moduleName, bmadDir) {
+  async update(moduleName, wizzDir) {
     const sourcePath = await this.findModuleSource(moduleName);
-    const targetPath = path.join(bmadDir, moduleName);
+    const targetPath = path.join(wizzDir, moduleName);
 
     if (!sourcePath) {
       throw new Error(`Module '${moduleName}' not found in any source location`);
@@ -414,10 +426,10 @@ class OfficialModules {
   /**
    * Remove a module
    * @param {string} moduleName - Name of the module to remove
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    */
-  async remove(moduleName, bmadDir) {
-    const targetPath = path.join(bmadDir, moduleName);
+  async remove(moduleName, wizzDir) {
+    const targetPath = path.join(wizzDir, moduleName);
 
     if (!(await fs.pathExists(targetPath))) {
       throw new Error(`Module '${moduleName}' is not installed`);
@@ -434,22 +446,22 @@ class OfficialModules {
   /**
    * Check if a module is installed
    * @param {string} moduleName - Name of the module
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    * @returns {boolean} True if module is installed
    */
-  async isInstalled(moduleName, bmadDir) {
-    const targetPath = path.join(bmadDir, moduleName);
+  async isInstalled(moduleName, wizzDir) {
+    const targetPath = path.join(wizzDir, moduleName);
     return await fs.pathExists(targetPath);
   }
 
   /**
    * Get installed module info
    * @param {string} moduleName - Name of the module
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    * @returns {Object|null} Module info or null if not installed
    */
-  async getInstalledInfo(moduleName, bmadDir) {
-    const targetPath = path.join(bmadDir, moduleName);
+  async getInstalledInfo(moduleName, wizzDir) {
+    const targetPath = path.join(wizzDir, moduleName);
 
     if (!(await fs.pathExists(targetPath))) {
       return null;
@@ -545,17 +557,17 @@ class OfficialModules {
    * This replaces the security-risky module installer pattern with declarative config
    * During updates, if a directory path changed, moves the old directory to the new path
    * @param {string} moduleName - Name of the module
-   * @param {string} bmadDir - Target bmad directory
+   * @param {string} wizzDir - Target wizz directory
    * @param {Object} options - Installation options
    * @param {Object} options.moduleConfig - Module configuration from config collector
    * @param {Object} options.existingModuleConfig - Previous module config (for detecting path changes during updates)
    * @param {Object} options.coreConfig - Core configuration
    * @returns {Promise<{createdDirs: string[], movedDirs: string[], createdWdsFolders: string[]}>} Created directories info
    */
-  async createModuleDirectories(moduleName, bmadDir, options = {}) {
+  async createModuleDirectories(moduleName, wizzDir, options = {}) {
     const moduleConfig = options.moduleConfig || {};
     const existingModuleConfig = options.existingModuleConfig || {};
-    const projectRoot = path.dirname(bmadDir);
+    const projectRoot = path.dirname(wizzDir);
     const emptyResult = { createdDirs: [], movedDirs: [], createdWdsFolders: [] };
 
     // Special handling for core module - it's in src/core-skills not src/modules
@@ -769,16 +781,16 @@ class OfficialModules {
   // ─── Config collection methods (merged from ConfigCollector) ───
 
   /**
-   * Find the bmad installation directory in a project
+   * Find the wizz installation directory in a project
    * V6+ installations can use ANY folder name but ALWAYS have _config/manifest.yaml
    * @param {string} projectDir - Project directory
-   * @returns {Promise<string>} Path to bmad directory
+   * @returns {Promise<string>} Path to wizz directory
    */
-  async findBmadDir(projectDir) {
+  async findWizzDir(projectDir) {
     // Check if project directory exists
     if (!(await fs.pathExists(projectDir))) {
       // Project doesn't exist yet, return default
-      return path.join(projectDir, 'bmad');
+      return path.join(projectDir, 'wizz');
     }
 
     // V6+ strategy: Look for ANY directory with _config/manifest.yaml
@@ -800,15 +812,15 @@ class OfficialModules {
 
     // No V6+ installation found, return default
     // This will be used for new installations
-    return path.join(projectDir, 'bmad');
+    return path.join(projectDir, 'wizz');
   }
 
   /**
-   * Detect the existing BMAD folder name in a project
+   * Detect the existing WIZZ folder name in a project
    * @param {string} projectDir - Project directory
    * @returns {Promise<string|null>} Folder name (just the name, not full path) or null if not found
    */
-  async detectExistingBmadFolder(projectDir) {
+  async detectExistingWizzFolder(projectDir) {
     // Check if project directory exists
     if (!(await fs.pathExists(projectDir))) {
       return null;
@@ -845,11 +857,11 @@ class OfficialModules {
       return false;
     }
 
-    // Find the actual bmad directory (handles custom folder names)
-    const bmadDir = await this.findBmadDir(projectDir);
+    // Find the actual wizz directory (handles custom folder names)
+    const wizzDir = await this.findWizzDir(projectDir);
 
-    // Check if bmad directory exists
-    if (!(await fs.pathExists(bmadDir))) {
+    // Check if wizz directory exists
+    if (!(await fs.pathExists(wizzDir))) {
       return false;
     }
 
@@ -859,7 +871,7 @@ class OfficialModules {
     // every reinstall.
     let foundAny = false;
     for (const fileName of ['config.toml', 'config.user.toml']) {
-      const tomlPath = path.join(bmadDir, fileName);
+      const tomlPath = path.join(wizzDir, fileName);
       if (!(await fs.pathExists(tomlPath))) continue;
       try {
         const content = await fs.readFile(tomlPath, 'utf8');
@@ -881,7 +893,7 @@ class OfficialModules {
     }
 
     // Fallback: legacy per-module config.yaml files (pre-v6 installations).
-    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+    const entries = await fs.readdir(wizzDir, { withFileTypes: true });
     const nonModuleDirs = new Set(['_config', '_memory', 'memory', 'docs', 'scripts', 'custom']);
     for (const entry of entries) {
       if (entry.isDirectory()) {
@@ -889,7 +901,7 @@ class OfficialModules {
           continue;
         }
 
-        const moduleConfigPath = path.join(bmadDir, entry.name, 'config.yaml');
+        const moduleConfigPath = path.join(wizzDir, entry.name, 'config.yaml');
 
         if (await fs.pathExists(moduleConfigPath)) {
           try {
@@ -1003,7 +1015,7 @@ class OfficialModules {
 
         const hasFieldsWithoutDefaults = questionKeys.some((key) => {
           const item = moduleConfig[key];
-          return item.default === undefined || item.default === null || item.default === '';
+          return OfficialModules.isMissingDefault(item.default);
         });
 
         results.push({
@@ -1435,7 +1447,7 @@ class OfficialModules {
         result = username.charAt(0).toUpperCase() + username.slice(1);
       }
     } catch {
-      // Do nothing, just return 'BMad'
+      // Do nothing, just return 'Wizz'
     }
     return result;
   }
@@ -1526,7 +1538,7 @@ class OfficialModules {
         await prompts.log.info(`Using default configuration for ${moduleDisplayName}`);
         // Use defaults for all questions
         for (const question of questions) {
-          const hasDefault = question.default !== undefined && question.default !== null && question.default !== '';
+          const hasDefault = !OfficialModules.isMissingDefault(question.default);
           if (hasDefault && typeof question.default !== 'function') {
             allAnswers[question.name] = question.default;
           }
@@ -1554,7 +1566,7 @@ class OfficialModules {
 
         if (useDefaults && moduleName !== 'core') {
           // Accept defaults - only ask questions that have NO default value
-          const questionsWithoutDefaults = questions.filter((q) => q.default === undefined || q.default === null || q.default === '');
+          const questionsWithoutDefaults = questions.filter((q) => OfficialModules.isMissingDefault(q.default));
 
           if (questionsWithoutDefaults.length > 0) {
             await prompts.log.message(`  Asking required questions for ${moduleName.toUpperCase()}...`);
@@ -1563,7 +1575,7 @@ class OfficialModules {
           }
 
           // For questions with defaults that weren't asked, we need to process them with their default values
-          const questionsWithDefaults = questions.filter((q) => q.default !== undefined && q.default !== null && q.default !== '');
+          const questionsWithDefaults = questions.filter((q) => !OfficialModules.isMissingDefault(q.default));
           for (const question of questionsWithDefaults) {
             // Skip function defaults - these are dynamic and will be evaluated later
             if (typeof question.default === 'function') {

package/tools/installer/modules/plugin-resolver.js

@@ -354,12 +354,12 @@ class PluginResolver {
 
   /**
    * Format a kebab-case or snake_case name into a display name.
-   * Strips common prefixes like "bmad-" or "bmad-agent-".
+   * Strips common prefixes like "wizz-" or "wizz-agent-".
    * @param {string} name - Raw name
    * @returns {string} Formatted display name
    */
   _formatDisplayName(name) {
-    let cleaned = name.replace(/^bmad-agent-/, '').replace(/^bmad-/, '');
+    let cleaned = name.replace(/^wizz-agent-/, '').replace(/^wizz-/, '');
     return cleaned
       .split(/[-_]/)
       .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
@@ -373,7 +373,7 @@ class PluginResolver {
    * @returns {string} Menu code (e.g., "CC" for "code-coach")
    */
   _generateMenuCode(name) {
-    const cleaned = name.replace(/^bmad-agent-/, '').replace(/^bmad-/, '');
+    const cleaned = name.replace(/^wizz-agent-/, '').replace(/^wizz-/, '');
     const words = cleaned.split(/[-_]/).filter((w) => w.length > 0);
     return words
       .map((w) => w.charAt(0).toUpperCase())

package/tools/installer/project-root.js

@@ -4,21 +4,21 @@ const yaml = require('yaml');
 const fs = require('./fs-native');
 
 /**
- * Find the BMAD project root directory by looking for package.json
- * or specific BMAD markers
+ * Find the WIZZ project root directory by looking for package.json
+ * or specific WIZZ markers
  */
 function findProjectRoot(startPath = __dirname) {
   let currentPath = path.resolve(startPath);
 
-  // Keep going up until we find package.json with bmad-method
+  // Keep going up until we find package.json with wizz-method
   while (currentPath !== path.dirname(currentPath)) {
     const packagePath = path.join(currentPath, 'package.json');
 
     if (fs.existsSync(packagePath)) {
       try {
         const pkg = fs.readJsonSync(packagePath);
-        // Check if this is the BMAD project
-        if (pkg.name === 'bmad-method' || fs.existsSync(path.join(currentPath, 'src', 'core-skills'))) {
+        // Check if this is the WIZZ project
+        if (pkg.name === 'wizz-method' || fs.existsSync(path.join(currentPath, 'src', 'core-skills'))) {
           return currentPath;
         }
       } catch {
@@ -77,7 +77,7 @@ function getModulePath(moduleName, ...segments) {
  * by ExternalModuleManager during install and are not copied into <src>/modules/.
  */
 function getExternalModuleCachePath(moduleName, ...segments) {
-  const base = process.env.BMAD_EXTERNAL_MODULES_CACHE || path.join(os.homedir(), '.bmad', 'cache', 'external-modules');
+  const base = process.env.WIZZ_EXTERNAL_MODULES_CACHE || path.join(os.homedir(), '.wizz', 'cache', 'external-modules');
   return path.join(base, moduleName, ...segments);
 }
 
@@ -85,9 +85,9 @@ function getExternalModuleCachePath(moduleName, ...segments) {
  * Locate an installed module's `module.yaml` by filesystem lookup only.
  *
  * Built-in modules (core, bmm) live under <src>. External official modules are
- * cloned into ~/.bmad/cache/external-modules/<name>/ with varying internal
+ * cloned into ~/.wizz/cache/external-modules/<name>/ with varying internal
  * layouts (some at src/module.yaml, some at skills/module.yaml, some nested).
- * Url-source custom modules are cloned into ~/.bmad/cache/custom-modules/<host>/<owner>/<repo>/
+ * Url-source custom modules are cloned into ~/.wizz/cache/custom-modules/<host>/<owner>/<repo>/
  * and are resolved by walking the cache and matching `code` or `name` from the
  * discovered module.yaml. Local custom-source modules are not cached; their
  * path is read from the CustomModuleManager resolution cache set during the
@@ -155,11 +155,11 @@ async function resolveInstalledModuleYaml(moduleName) {
     if (found) return found;
   }
 
-  // Community modules are cloned to ~/.bmad/cache/community-modules/<name>/
+  // Community modules are cloned to ~/.wizz/cache/community-modules/<name>/
   // (parallel to the external-modules cache used above). Search there too so
   // collectAgentsFromModuleYaml and writeCentralConfig can locate community
   // module.yaml files regardless of how nested the layout is.
-  const communityCacheRoot = path.join(os.homedir(), '.bmad', 'cache', 'community-modules', moduleName);
+  const communityCacheRoot = path.join(os.homedir(), '.wizz', 'cache', 'community-modules', moduleName);
   if (await fs.pathExists(communityCacheRoot)) {
     const found = await searchRoot(communityCacheRoot);
     if (found) return found;
@@ -180,15 +180,15 @@ async function resolveInstalledModuleYaml(moduleName) {
     // Resolution cache unavailable — continue
   }
 
-  // Fallback: url-source custom modules cloned to ~/.bmad/cache/custom-modules/.
+  // Fallback: url-source custom modules cloned to ~/.wizz/cache/custom-modules/.
   // Walk every cached repo, enumerate ALL module.yaml files via searchRootAll
   // (a single repo can host multiple plugins in discovery mode), and match by
   // the yaml's `code` or `name` field. This works on re-install runs where
   // _resolutionCache is empty and covers both discovery-mode (with marketplace.json)
-  // and direct-mode modules, since we identify repo roots by .bmad-source.json
+  // and direct-mode modules, since we identify repo roots by .wizz-source.json
   // (written by cloneRepo) or .claude-plugin/ rather than by marketplace.json.
   try {
-    const customCacheDir = path.join(os.homedir(), '.bmad', 'cache', 'custom-modules');
+    const customCacheDir = path.join(os.homedir(), '.wizz', 'cache', 'custom-modules');
     if (await fs.pathExists(customCacheDir)) {
       const { CustomModuleManager } = require('./modules/custom-module-manager');
       const customMgr = new CustomModuleManager();

package/tools/installer/prompts.js

@@ -1,5 +1,5 @@
 /**
- * @clack/prompts wrapper for BMAD CLI
+ * @clack/prompts wrapper for WIZZ CLI
  *
  * This module provides a unified interface for CLI prompts using @clack/prompts.
  * It replaces Inquirer.js to fix Windows arrow key navigation issues (libuv #852).

package/tools/installer/set-overrides.js

@@ -230,16 +230,16 @@ async function tomlHasKey(filePath, section, key) {
  * (not in either file yet), team scope is the safe default.
  *
  * @param {Object<string, Object<string, string>>} overrides
- * @param {string} bmadDir absolute path to `_wizz/`
+ * @param {string} wizzDir absolute path to `_wizz/`
  * @returns {Promise<Array<{module:string,key:string,scope:'team'|'user',file:string}>>}
  *          a list of applied entries (for caller logging)
  */
-async function applySetOverrides(overrides, bmadDir) {
+async function applySetOverrides(overrides, wizzDir) {
   const applied = [];
   if (!overrides || typeof overrides !== 'object') return applied;
 
-  const teamPath = path.join(bmadDir, 'config.toml');
-  const userPath = path.join(bmadDir, 'config.user.toml');
+  const teamPath = path.join(wizzDir, 'config.toml');
+  const userPath = path.join(wizzDir, 'config.user.toml');
 
   for (const moduleCode of Object.keys(overrides)) {
     // Skip overrides for modules not actually installed. The installer writes
@@ -247,7 +247,7 @@ async function applySetOverrides(overrides, bmadDir) {
     // so its presence is a reliable "is this module here?" signal that works
     // for both fresh installs and quick-updates without coupling to caller-
     // supplied module lists.
-    const moduleConfigYaml = path.join(bmadDir, moduleCode, 'config.yaml');
+    const moduleConfigYaml = path.join(wizzDir, moduleCode, 'config.yaml');
     if (!(await fs.pathExists(moduleConfigYaml))) {
       continue;
     }
@@ -291,7 +291,7 @@ async function applySetOverrides(overrides, bmadDir) {
     // value lives in the per-module yaml but won't be re-emitted into
     // config.toml on the next install (the schema-strict partition drops
     // it); re-pass `--set` if you need it sticky.
-    const moduleYamlPath = path.join(bmadDir, moduleCode, 'config.yaml');
+    const moduleYamlPath = path.join(wizzDir, moduleCode, 'config.yaml');
     if (await fs.pathExists(moduleYamlPath)) {
       try {
         const text = await fs.readFile(moduleYamlPath, 'utf8');

package/tools/installer/ui.js

@@ -110,7 +110,7 @@ async function getModuleVersion(moduleCode, { repoUrl = null, registryDefault =
  * UI utilities for the installer
  */
 class UI {
-  async _retainUnavailableInstalledModules(selectedModules, installedModuleIds, bmadDir, options = {}) {
+  async _retainUnavailableInstalledModules(selectedModules, installedModuleIds, wizzDir, options = {}) {
     const { OfficialModules } = require('./modules/official-modules');
     const officialCodes = new Set(['core']);
 
@@ -135,7 +135,7 @@ class UI {
       if (!selectedSet.has(moduleId) && !options.preserveUnselected) continue;
       if (officialCodes.has(moduleId)) continue;
 
-      const customSource = await customMgr.findModuleSourceByCode(moduleId, { bmadDir });
+      const customSource = await customMgr.findModuleSourceByCode(moduleId, { wizzDir });
       if (!customSource) {
         preserveModules.push(moduleId);
       }
@@ -161,7 +161,7 @@ class UI {
     const messageLoader = new MessageLoader();
     await messageLoader.displayStartMessage();
 
-    // Probe the local Python before any other prompts: several BMAD features
+    // Probe the local Python before any other prompts: several WIZZ features
     // (memlog session memory, TOML config resolution) need Python 3.11+ at
     // runtime. Warn-don't-block, but require an explicit ack so the warning
     // can't scroll past unseen. The installer runs in the destination
@@ -213,10 +213,10 @@ class UI {
 
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(confirmedDirectory);
+    const { wizzDir } = await installer.findWizzDir(confirmedDirectory);
 
-    // Check if there's an existing BMAD installation
-    const hasExistingInstall = await fs.pathExists(bmadDir);
+    // Check if there's an existing WIZZ installation
+    const hasExistingInstall = await fs.pathExists(wizzDir);
 
     // Track action type (only set if there's an existing installation)
     let actionType;
@@ -224,7 +224,7 @@ class UI {
     // Only show action menu if there's an existing installation
     if (hasExistingInstall) {
       // Get version information
-      const { existingInstall, bmadDir } = await this.getExistingInstallation(confirmedDirectory);
+      const { existingInstall, wizzDir } = await this.getExistingInstallation(confirmedDirectory);
 
       // Build menu choices dynamically
       const choices = [];
@@ -321,7 +321,7 @@ class UI {
           selectedModules.unshift('core');
         }
 
-        const retainedModuleResult = await this._retainUnavailableInstalledModules(selectedModules, installedModuleIds, bmadDir, {
+        const retainedModuleResult = await this._retainUnavailableInstalledModules(selectedModules, installedModuleIds, wizzDir, {
           preserveUnselected: options.yes && !options.modules,
         });
         selectedModules = retainedModuleResult.selectedModules;
@@ -339,7 +339,7 @@ class UI {
         // default Y, major default N). Legacy entries with no channel are
         // migrated here too. Mutates channelOptions.pins to lock rejections.
         await this._resolveUpdateChannels({
-          bmadDir,
+          wizzDir,
           selectedModules,
           channelOptions,
           yes: options.yes || false,
@@ -503,8 +503,8 @@ class UI {
     const { ExistingInstall } = require('./core/existing-install');
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(projectDir || process.cwd());
-    const existingInstall = await ExistingInstall.detect(bmadDir);
+    const { wizzDir } = await installer.findWizzDir(projectDir || process.cwd());
+    const existingInstall = await ExistingInstall.detect(wizzDir);
     const configuredIdes = existingInstall.ides;
 
     // Get IDE manager to fetch available IDEs dynamically
@@ -732,17 +732,17 @@ class UI {
   /**
    * Get existing installation info and installed modules
    * @param {string} directory - Installation directory
-   * @returns {Object} Object with existingInstall, installedModuleIds, installedModuleVersions, and bmadDir
+   * @returns {Object} Object with existingInstall, installedModuleIds, installedModuleVersions, and wizzDir
    */
   async getExistingInstallation(directory) {
     const { ExistingInstall } = require('./core/existing-install');
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(directory);
-    const existingInstall = await ExistingInstall.detect(bmadDir);
+    const { wizzDir } = await installer.findWizzDir(directory);
+    const existingInstall = await ExistingInstall.detect(wizzDir);
     const installedModuleIds = new Set(existingInstall.moduleIds);
     const installedModuleVersions = new Map();
-    const manifestModules = await manifest.getAllModuleVersions(bmadDir);
+    const manifestModules = await manifest.getAllModuleVersions(wizzDir);
 
     for (const module of manifestModules) {
       if (module?.name && module.version) {
@@ -760,7 +760,7 @@ class UI {
       installedModuleVersions.set('core', existingInstall.version);
     }
 
-    return { existingInstall, installedModuleIds, installedModuleVersions, bmadDir };
+    return { existingInstall, installedModuleIds, installedModuleVersions, wizzDir };
   }
 
   /**
@@ -1355,15 +1355,15 @@ class UI {
       if (stats.isDirectory()) {
         const files = await fs.readdir(directory);
         if (files.length > 0) {
-          // Check for any bmad installation (any folder with _config/manifest.yaml)
+          // Check for any wizz installation (any folder with _config/manifest.yaml)
           const { Installer } = require('./core/installer');
           const installer = new Installer();
-          const bmadResult = await installer.findBmadDir(directory);
-          const hasBmadInstall =
-            (await fs.pathExists(bmadResult.bmadDir)) && (await fs.pathExists(path.join(bmadResult.bmadDir, '_config', 'manifest.yaml')));
+          const wizzResult = await installer.findWizzDir(directory);
+          const hasWizzInstall =
+            (await fs.pathExists(wizzResult.wizzDir)) && (await fs.pathExists(path.join(wizzResult.wizzDir, '_config', 'manifest.yaml')));
 
-          const bmadNote = hasBmadInstall ? ` including existing Wizz installation (${path.basename(bmadResult.bmadDir)})` : '';
-          await prompts.log.message(`Directory exists and contains ${files.length} item(s)${bmadNote}`);
+          const wizzNote = hasWizzInstall ? ` including existing Wizz installation (${path.basename(wizzResult.wizzDir)})` : '';
+          await prompts.log.message(`Directory exists and contains ${files.length} item(s)${wizzNote}`);
         } else {
           await prompts.log.message('Directory exists and is empty');
         }
@@ -1601,8 +1601,8 @@ class UI {
     const { ExistingInstall } = require('./core/existing-install');
     const { Installer } = require('./core/installer');
     const installer = new Installer();
-    const { bmadDir } = await installer.findBmadDir(directory);
-    const existingInstall = await ExistingInstall.detect(bmadDir);
+    const { wizzDir } = await installer.findWizzDir(directory);
+    const existingInstall = await ExistingInstall.detect(wizzDir);
     return existingInstall.ides;
   }
 
@@ -1695,12 +1695,12 @@ class UI {
    * @param {Object} statusData - Status data with modules, installation info, and available updates
    */
   async displayStatus(statusData) {
-    const { installation, modules, availableUpdates, bmadDir } = statusData;
+    const { installation, modules, availableUpdates, wizzDir } = statusData;
 
     // Installation info
     const infoLines = [
       `Version:       ${installation.version || 'unknown'}`,
-      `Location:      ${bmadDir}`,
+      `Location:      ${wizzDir}`,
       `Installed:     ${new Date(installation.installDate).toLocaleDateString()}`,
       `Last Updated:  ${installation.lastUpdated ? new Date(installation.lastUpdated).toLocaleDateString() : 'unknown'}`,
     ];
@@ -1855,10 +1855,10 @@ class UI {
    * Decisions that freeze the current version are applied by adding a pin to
    * `channelOptions.pins` so downstream clone logic honors them.
    */
-  async _resolveUpdateChannels({ bmadDir, selectedModules, channelOptions, yes }) {
+  async _resolveUpdateChannels({ wizzDir, selectedModules, channelOptions, yes }) {
     const { Manifest } = require('./core/manifest');
     const manifestObj = new Manifest();
-    const manifest = await manifestObj.read(bmadDir);
+    const manifest = await manifestObj.read(wizzDir);
     const existingByName = new Map();
     for (const m of manifest?.modulesDetailed || []) {
       if (m?.name) existingByName.set(m.name, m);
@@ -1899,7 +1899,7 @@ class UI {
       if (!info) continue;
       // Bundled modules (core/bmm) ship with the installer binary itself —
       // their version is stapled to the CLI version, not a git tag. Skip
-      // tag-API lookups for them; the "upgrade" mechanism is `npx bmad@X install`.
+      // tag-API lookups for them; the "upgrade" mechanism is `npx wizz@X install`.
       if (info.builtIn) continue;
 
       const repoUrl = info.url;

package/tools/installer/yaml-format.js

@@ -14,7 +14,7 @@ async function initializeModules() {
 }
 
 /**
- * YAML Formatter and Linter for BMad-Method
+ * YAML Formatter and Linter for Wizz-Method
  * Formats and validates YAML files and YAML embedded in Markdown
  */