wizz-method 1.0.1 → 1.0.3

package/tools/installer/core/legacy-warnings.js

@@ -3,13 +3,13 @@ const path = require('node:path');
 const semver = require('semver');
 const fs = require('../fs-native');
 const prompts = require('../prompts');
-const { BMAD_FOLDER_NAME } = require('../ide/shared/path-utils');
-const { getInstalledCanonicalIds, isBmadOwnedEntry } = require('../ide/shared/installed-skills');
+const { WIZZ_FOLDER_NAME } = require('../ide/shared/path-utils');
+const { getInstalledCanonicalIds, isWizzOwnedEntry } = require('../ide/shared/installed-skills');
 
 const MIN_NATIVE_SKILLS_VERSION = '6.1.0';
 
-// Pre-v6.1.0 paths: BMAD used to install commands/workflows/etc in tool-specific dirs.
-// In v6.1.0 BMAD switched to native SKILL.md format.
+// Pre-v6.1.0 paths: WIZZ used to install commands/workflows/etc in tool-specific dirs.
+// In v6.1.0 WIZZ switched to native SKILL.md format.
 const LEGACY_COMMAND_PATHS = [
   '.agent/workflows',
   '.augment/commands',
@@ -38,7 +38,7 @@ const LEGACY_COMMAND_PATHS = [
 ];
 
 // Skill paths that moved to the cross-tool .agents/skills/ standard.
-// Users upgrading from a prior install may have stale BMAD skills here that
+// Users upgrading from a prior install may have stale WIZZ skills here that
 // the AI tool will load alongside the new ones, causing duplicates.
 const LEGACY_SKILL_PATHS = [
   '.augment/skills',
@@ -81,8 +81,8 @@ function resolveLegacyPath(projectRoot, p) {
 }
 
 async function findStaleLegacyDirs(projectRoot) {
-  const bmadDir = path.join(projectRoot, BMAD_FOLDER_NAME);
-  const canonicalIds = await getInstalledCanonicalIds(bmadDir);
+  const wizzDir = path.join(projectRoot, WIZZ_FOLDER_NAME);
+  const canonicalIds = await getInstalledCanonicalIds(wizzDir);
 
   const findings = [];
   for (const legacyPath of LEGACY_PATHS) {
@@ -90,9 +90,9 @@ async function findStaleLegacyDirs(projectRoot) {
     if (!(await fs.pathExists(resolved))) continue;
     try {
       const entries = await fs.readdir(resolved);
-      const bmadEntries = entries.filter((e) => isBmadOwnedEntry(e, canonicalIds));
-      if (bmadEntries.length > 0) {
-        findings.push({ path: resolved, displayPath: legacyPath, count: bmadEntries.length, entries: bmadEntries });
+      const wizzEntries = entries.filter((e) => isWizzOwnedEntry(e, canonicalIds));
+      if (wizzEntries.length > 0) {
+        findings.push({ path: resolved, displayPath: legacyPath, count: wizzEntries.length, entries: wizzEntries });
       }
     } catch {
       // Unreadable dir — skip
@@ -116,20 +116,20 @@ async function warnPreNativeSkillsLegacy({ projectRoot, existingVersion } = {})
 
   if (versionTriggered) {
     await prompts.log.warn(
-      `Detected previous BMAD install v${existingVersion} (pre-${MIN_NATIVE_SKILLS_VERSION}). ` +
-        `BMAD switched to native skills format in v${MIN_NATIVE_SKILLS_VERSION}; old command/workflow directories from your prior install may still be present.`,
+      `Detected previous WIZZ install v${existingVersion} (pre-${MIN_NATIVE_SKILLS_VERSION}). ` +
+        `WIZZ switched to native skills format in v${MIN_NATIVE_SKILLS_VERSION}; old command/workflow directories from your prior install may still be present.`,
     );
   }
 
   if (staleDirs.length > 0) {
     await prompts.log.warn(
-      `Found stale BMAD entries in ${staleDirs.length} legacy location(s) that the new installer no longer manages. ` +
+      `Found stale WIZZ entries in ${staleDirs.length} legacy location(s) that the new installer no longer manages. ` +
         `Your AI tool may load these alongside the new skills, causing duplicates. Remove them manually:`,
     );
     for (const finding of staleDirs) {
-      // Print each entry by exact name. A `bmad*` glob would (a) miss
+      // Print each entry by exact name. A `wizz*` glob would (a) miss
       // custom-module skills the canonicalId scan now picks up, and
-      // (b) match bmad-os-* utility skills the user should keep.
+      // (b) match wizz-os-* utility skills the user should keep.
       const entries = finding.entries || [];
       for (const entry of entries) {
         await prompts.log.message(`    rm -rf "${path.join(finding.path, entry)}"`);
@@ -137,7 +137,7 @@ async function warnPreNativeSkillsLegacy({ projectRoot, existingVersion } = {})
     }
   } else if (versionTriggered) {
     await prompts.log.message(
-      '  No stale legacy directories detected, but if your AI tool shows duplicate BMAD commands after install, check for old `bmad-*` entries in tool-specific dirs (e.g. .claude/commands, .cursor/commands).',
+      '  No stale legacy directories detected, but if your AI tool shows duplicate WIZZ commands after install, check for old `wizz-*` entries in tool-specific dirs (e.g. .claude/commands, .cursor/commands).',
     );
   }
 }

package/tools/installer/core/manifest-generator.js

@@ -33,20 +33,20 @@ class ManifestGenerator {
 
   /**
    * Generate all manifests for the installation
-   * @param {string} bmadDir - _wizz
+   * @param {string} wizzDir - _wizz
    * @param {Array} selectedModules - Selected modules for installation
    * @param {Array} installedFiles - All installed files (optional, for hash tracking)
    */
-  async generateManifests(bmadDir, selectedModules, installedFiles = [], options = {}) {
+  async generateManifests(wizzDir, selectedModules, installedFiles = [], options = {}) {
     // Create _config directory if it doesn't exist
-    const cfgDir = path.join(bmadDir, '_config');
+    const cfgDir = path.join(wizzDir, '_config');
     await fs.ensureDir(cfgDir);
 
     // Store modules list (all modules including preserved ones)
     const preservedModules = options.preservedModules || [];
 
-    // Scan the bmad directory to find all actually installed modules
-    const installedModules = await this.scanInstalledModules(bmadDir);
+    // Scan the wizz directory to find all actually installed modules
+    const installedModules = await this.scanInstalledModules(wizzDir);
 
     // Since custom modules are now installed the same way as regular modules,
     // we don't need to exclude them from manifest generation
@@ -55,8 +55,8 @@ class ManifestGenerator {
     this.modules = allModules;
     this.updatedModules = allModules; // Include ALL modules (including custom) for scanning
 
-    this.bmadDir = bmadDir;
-    this.bmadFolderName = path.basename(bmadDir); // Get the actual folder name (e.g., '_wizz' or 'bmad')
+    this.wizzDir = wizzDir;
+    this.wizzFolderName = path.basename(wizzDir); // Get the actual folder name (e.g., '_wizz' or 'wizz')
     this.allInstalledFiles = installedFiles;
 
     if (!Object.prototype.hasOwnProperty.call(options, 'ides')) {
@@ -81,7 +81,7 @@ class ManifestGenerator {
     await this.collectAgentsFromModuleYaml();
 
     // Write manifest files and collect their paths
-    const [teamConfigPath, userConfigPath] = await this.writeCentralConfig(bmadDir, options.moduleConfigs || {});
+    const [teamConfigPath, userConfigPath] = await this.writeCentralConfig(wizzDir, options.moduleConfigs || {});
     const manifestFiles = [
       await this.writeMainManifest(cfgDir),
       await this.writeSkillManifest(cfgDir),
@@ -90,7 +90,7 @@ class ManifestGenerator {
       await this.writeFilesManifest(cfgDir),
     ];
 
-    await this.ensureCustomConfigStubs(bmadDir);
+    await this.ensureCustomConfigStubs(wizzDir);
 
     return {
       skills: this.skills.length,
@@ -110,10 +110,10 @@ class ManifestGenerator {
   async collectSkills() {
     this.skills = [];
     this.skillClaimedDirs = new Set();
-    const debug = process.env.BMAD_DEBUG_MANIFEST === 'true';
+    const debug = process.env.WIZZ_DEBUG_MANIFEST === 'true';
 
     for (const moduleName of this.updatedModules) {
-      const modulePath = path.join(this.bmadDir, moduleName);
+      const modulePath = path.join(this.wizzDir, moduleName);
       if (!(await fs.pathExists(modulePath))) continue;
 
       // Recursive walk skipping . and _ prefixed dirs
@@ -136,8 +136,8 @@ class ManifestGenerator {
           // Build path relative from module root (points to SKILL.md — the permanent entrypoint)
           const relativePath = path.relative(modulePath, dir).split(path.sep).join('/');
           const installPath = relativePath
-            ? `${this.bmadFolderName}/${moduleName}/${relativePath}/${skillFile}`
-            : `${this.bmadFolderName}/${moduleName}/${skillFile}`;
+            ? `${this.wizzFolderName}/${moduleName}/${relativePath}/${skillFile}`
+            : `${this.wizzFolderName}/${moduleName}/${skillFile}`;
 
           // Native SKILL.md entrypoints always derive canonicalId from directory name.
           const canonicalId = dirName;
@@ -241,12 +241,12 @@ class ManifestGenerator {
    */
   async collectAgentsFromModuleYaml() {
     this.agents = [];
-    const debug = process.env.BMAD_DEBUG_MANIFEST === 'true';
+    const debug = process.env.WIZZ_DEBUG_MANIFEST === 'true';
 
     for (const moduleName of this.updatedModules) {
       const moduleYamlPath = await resolveInstalledModuleYaml(moduleName);
       if (!moduleYamlPath) {
-        // External modules live in ~/.bmad/cache/external-modules, not src/modules.
+        // External modules live in ~/.wizz/cache/external-modules, not src/modules.
         // Warn rather than silently skip so missing agent rosters don't vanish
         // from config.toml without notice.
         console.warn(
@@ -335,7 +335,7 @@ class ManifestGenerator {
 
     for (const moduleName of this.modules) {
       // Get fresh version info from source
-      const versionInfo = await manifestObj.getModuleVersionInfo(moduleName, this.bmadDir);
+      const versionInfo = await manifestObj.getModuleVersionInfo(moduleName, this.wizzDir);
 
       // Get existing install date if available
       const existing = existingModulesMap.get(moduleName);
@@ -425,9 +425,9 @@ class ManifestGenerator {
    * _wizz/custom/config.toml and _wizz/custom/config.user.toml (never touched by installer).
    * @returns {string[]} Paths to the written config files
    */
-  async writeCentralConfig(bmadDir, moduleConfigs) {
-    const teamPath = path.join(bmadDir, 'config.toml');
-    const userPath = path.join(bmadDir, 'config.user.toml');
+  async writeCentralConfig(wizzDir, moduleConfigs) {
+    const teamPath = path.join(wizzDir, 'config.toml');
+    const userPath = path.join(wizzDir, 'config.user.toml');
 
     // Load each module's source module.yaml to determine scope per prompt key.
     // Default scope is 'team' when the prompt doesn't declare one.
@@ -623,8 +623,8 @@ class ManifestGenerator {
    * Create empty _wizz/custom/config.toml and _wizz/custom/config.user.toml stubs
    * on first install only. Installer never touches these files again after creation.
    */
-  async ensureCustomConfigStubs(bmadDir) {
-    const customDir = path.join(bmadDir, 'custom');
+  async ensureCustomConfigStubs(wizzDir) {
+    const customDir = path.join(wizzDir, 'custom');
     await fs.ensureDir(customDir);
 
     const stubs = [
@@ -689,8 +689,8 @@ class ManifestGenerator {
     if (this.allInstalledFiles && this.allInstalledFiles.length > 0) {
       // Process all installed files
       for (const filePath of this.allInstalledFiles) {
-        // Store paths relative to bmadDir (no folder prefix)
-        const relativePath = filePath.replace(this.bmadDir, '').replaceAll('\\', '/').replace(/^\//, '');
+        // Store paths relative to wizzDir (no folder prefix)
+        const relativePath = filePath.replace(this.wizzDir, '').replaceAll('\\', '/').replace(/^\//, '');
         const ext = path.extname(filePath).toLowerCase();
         const fileName = path.basename(filePath, ext);
 
@@ -713,8 +713,8 @@ class ManifestGenerator {
       // Fallback: use the collected workflows/agents/tasks
       for (const file of this.files) {
         // Strip the folder prefix if present (for consistency)
-        const relPath = file.path.replace(this.bmadFolderName + '/', '');
-        const filePath = path.join(this.bmadDir, relPath);
+        const relPath = file.path.replace(this.wizzFolderName + '/', '');
+        const filePath = path.join(this.wizzDir, relPath);
         const hash = await this.calculateFileHash(filePath);
         allFiles.push({
           ...file,
@@ -741,15 +741,15 @@ class ManifestGenerator {
   }
 
   /**
-   * Scan the bmad directory to find all installed modules
-   * @param {string} bmadDir - Path to bmad directory
+   * Scan the wizz directory to find all installed modules
+   * @param {string} wizzDir - Path to wizz directory
    * @returns {Array} List of module names
    */
-  async scanInstalledModules(bmadDir) {
+  async scanInstalledModules(wizzDir) {
     const modules = [];
 
     try {
-      const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+      const entries = await fs.readdir(wizzDir, { withFileTypes: true });
 
       for (const entry of entries) {
         // Skip if not a directory or is a special directory
@@ -758,7 +758,7 @@ class ManifestGenerator {
         }
 
         // Check if this looks like a module (has agents directory or skill manifests)
-        const modulePath = path.join(bmadDir, entry.name);
+        const modulePath = path.join(wizzDir, entry.name);
         const hasAgents = await fs.pathExists(path.join(modulePath, 'agents'));
         const hasSkills = await this._hasSkillMdRecursive(modulePath);
 

package/tools/installer/core/manifest.js

@@ -18,26 +18,26 @@ function isValidNpmPackageName(packageName) {
 class Manifest {
   /**
    * Create a new manifest
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @param {Object} data - Manifest data
    * @param {Array} installedFiles - List of installed files (no longer used, files tracked in files-manifest.csv)
    */
-  async create(bmadDir, data, installedFiles = []) {
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml');
+  async create(wizzDir, data, installedFiles = []) {
+    const manifestPath = path.join(wizzDir, '_config', 'manifest.yaml');
     const yaml = require('yaml');
 
     // Ensure _config directory exists
     await fs.ensureDir(path.dirname(manifestPath));
 
-    // Get the BMad version from package.json
-    const bmadVersion = data.version || require(path.join(process.cwd(), 'package.json')).version;
+    // Get the Wizz version from package.json
+    const wizzVersion = data.version || require(path.join(process.cwd(), 'package.json')).version;
 
     // Convert module list to new detailed format
     const moduleDetails = [];
     if (data.modules && Array.isArray(data.modules)) {
       for (const moduleName of data.modules) {
-        // Core and BMM modules use the BMad version
-        const moduleVersion = moduleName === 'core' || moduleName === 'bmm' ? bmadVersion : null;
+        // Core and BMM modules use the Wizz version
+        const moduleVersion = moduleName === 'core' || moduleName === 'bmm' ? wizzVersion : null;
         const now = data.installDate || new Date().toISOString();
 
         moduleDetails.push({
@@ -53,7 +53,7 @@ class Manifest {
     // Structure the manifest data
     const manifestData = {
       installation: {
-        version: bmadVersion,
+        version: wizzVersion,
         installDate: data.installDate || new Date().toISOString(),
         lastUpdated: data.lastUpdated || new Date().toISOString(),
       },
@@ -79,11 +79,11 @@ class Manifest {
 
   /**
    * Read existing manifest
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @returns {Object|null} Manifest data or null if not found
    */
-  async read(bmadDir) {
-    const yamlPath = path.join(bmadDir, '_config', 'manifest.yaml');
+  async read(wizzDir) {
+    const yamlPath = path.join(wizzDir, '_config', 'manifest.yaml');
     const yaml = require('yaml');
 
     if (await fs.pathExists(yamlPath)) {
@@ -120,11 +120,11 @@ class Manifest {
 
   /**
    * Read raw manifest data without flattening
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @returns {Object|null} Raw manifest data or null if not found
    */
-  async _readRaw(bmadDir) {
-    const yamlPath = path.join(bmadDir, '_config', 'manifest.yaml');
+  async _readRaw(wizzDir) {
+    const yamlPath = path.join(wizzDir, '_config', 'manifest.yaml');
     const yaml = require('yaml');
 
     if (await fs.pathExists(yamlPath)) {
@@ -162,12 +162,12 @@ class Manifest {
   /**
    * Add a module to the manifest with optional version info
    * If module already exists, update its version info
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @param {string} moduleName - Module name to add
    * @param {Object} options - Optional version info
    */
-  async addModule(bmadDir, moduleName, options = {}) {
-    let manifest = await this._readRaw(bmadDir);
+  async addModule(wizzDir, moduleName, options = {}) {
+    let manifest = await this._readRaw(wizzDir);
     if (!manifest) {
       // Bootstrap a minimal manifest if it doesn't exist yet
       // (e.g., skill-only modules with no agents to compile)
@@ -217,16 +217,16 @@ class Manifest {
       };
     }
 
-    await this._writeRaw(bmadDir, manifest);
+    await this._writeRaw(wizzDir, manifest);
   }
 
   /**
    * Get all modules with their version info
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @returns {Array} Array of module info objects
    */
-  async getAllModuleVersions(bmadDir) {
-    const manifest = await this._readRaw(bmadDir);
+  async getAllModuleVersions(wizzDir) {
+    const manifest = await this._readRaw(wizzDir);
     if (!manifest || !manifest.modules) {
       return [];
     }
@@ -236,12 +236,12 @@ class Manifest {
 
   /**
    * Write raw manifest data to file
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @param {Object} manifestData - Raw manifest data to write
    */
-  async _writeRaw(bmadDir, manifestData) {
+  async _writeRaw(wizzDir, manifestData) {
     const yaml = require('yaml');
-    const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml');
+    const manifestPath = path.join(wizzDir, '_config', 'manifest.yaml');
 
     await fs.ensureDir(path.dirname(manifestPath));
 
@@ -274,11 +274,11 @@ class Manifest {
   /**
    * Get module version info from source
    * @param {string} moduleName - Module name/code
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @param {string} moduleSourcePath - Optional source path for custom modules
    * @returns {Object} Version info object with version, source, npmPackage, repoUrl
    */
-  async getModuleVersionInfo(moduleName, bmadDir, moduleSourcePath = null) {
+  async getModuleVersionInfo(moduleName, wizzDir, moduleSourcePath = null) {
     // Resolve source type first, then read version with the correct path context
     if (['core', 'bmm'].includes(moduleName)) {
       const versionInfo = await resolveModuleVersion(moduleName, { moduleSourcePath });
@@ -314,7 +314,7 @@ class Manifest {
     const { CustomModuleManager } = require('../modules/custom-module-manager');
     const customMgr = new CustomModuleManager();
     const resolved = customMgr.getResolution(moduleName);
-    const customSource = await customMgr.findModuleSourceByCode(moduleName, { bmadDir });
+    const customSource = await customMgr.findModuleSourceByCode(moduleName, { wizzDir });
     if (customSource || resolved) {
       const versionInfo = await resolveModuleVersion(moduleName, {
         moduleSourcePath: moduleSourcePath || customSource,
@@ -394,12 +394,12 @@ class Manifest {
 
   /**
    * Check for available updates for installed modules
-   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} wizzDir - Path to wizz directory
    * @returns {Array} Array of update info objects
    */
-  async checkForUpdates(bmadDir) {
+  async checkForUpdates(wizzDir) {
     const semver = require('semver');
-    const modules = await this.getAllModuleVersions(bmadDir);
+    const modules = await this.getAllModuleVersions(wizzDir);
     const updates = [];
 
     for (const module of modules) {

package/tools/installer/core/python-check.js

@@ -3,14 +3,14 @@ const prompts = require('../prompts');
 
 // Python 3.11 added stdlib `tomllib` (PEP 680), which the shared scripts in
 // src/scripts/ (resolve_config.py, resolve_customization.py) require to read
-// BMAD's TOML config files. memlog.py is more lenient and runs on 3.8+.
+// WIZZ's TOML config files. memlog.py is more lenient and runs on 3.8+.
 const PYTHON_FULL_SUPPORT = { major: 3, minor: 11 };
 const PYTHON_PARTIAL_SUPPORT = { major: 3, minor: 8 };
 
 // Every runtime call site (skill steps, on_complete hooks) invokes a literal
-// `python3`, so only that command's version vouches for BMAD features. The
+// `python3`, so only that command's version vouches for WIZZ features. The
 // fallback probes exist to tell the user "Python is installed, but not under
-// the name BMAD uses" instead of a misleading "No Python found".
+// the name WIZZ uses" instead of a misleading "No Python found".
 const RUNTIME_COMMAND = 'python3';
 const PROBE_CANDIDATES =
   process.platform === 'win32'
@@ -43,7 +43,7 @@ function parsePythonVersion(output) {
 }
 
 /**
- * Classify a detected Python version against BMAD's feature requirements.
+ * Classify a detected Python version against WIZZ's feature requirements.
  * @param {{major: number, minor: number}|null} version
  * @returns {'full'|'partial'|'unsupported'|'none'}
  */
@@ -88,7 +88,7 @@ function probeVersion(candidate) {
  * Probe the local environment for a Python interpreter.
  * Tries each candidate command and returns the first that reports a version.
  * `isRuntimeCommand` is true only when the match is `python3` — the command
- * BMAD scripts actually invoke.
+ * WIZZ scripts actually invoke.
  * @returns {{command: string, version: {major: number, minor: number, patch: number, raw: string}, isRuntimeCommand: boolean}|null}
  */
 function detectPython() {
@@ -117,9 +117,9 @@ function upgradeHints() {
 }
 
 /**
- * Check the local Python environment and warn about degraded BMAD features.
+ * Check the local Python environment and warn about degraded WIZZ features.
  *
- * Warn-don't-block: most of BMAD works without Python, so the install always
+ * Warn-don't-block: most of WIZZ works without Python, so the install always
  * may proceed — but the user must explicitly acknowledge the warning so it
  * can't scroll past unseen. In non-interactive runs (--yes, or stdin is not
  * a TTY) the warning is logged and the install continues without a prompt.