wizz-method 1.19.0 → 2.1.0

package/tools/installer/file-ops.js

@@ -1,204 +0,0 @@
-const fs = require('./fs-native');
-const path = require('node:path');
-const crypto = require('node:crypto');
-
-/**
- * File operations utility class
- */
-class FileOps {
-  /**
-   * Copy a directory recursively
-   * @param {string} source - Source directory
-   * @param {string} dest - Destination directory
-   * @param {Object} options - Copy options
-   */
-  async copyDirectory(source, dest, options = {}) {
-    const defaultOptions = {
-      overwrite: true,
-      errorOnExist: false,
-      filter: (src) => !this.shouldIgnore(src),
-    };
-
-    const copyOptions = { ...defaultOptions, ...options };
-    await fs.copy(source, dest, copyOptions);
-  }
-
-  /**
-   * Sync directory (selective copy preserving modifications)
-   * @param {string} source - Source directory
-   * @param {string} dest - Destination directory
-   */
-  async syncDirectory(source, dest) {
-    const sourceFiles = await this.getFileList(source);
-
-    for (const file of sourceFiles) {
-      const sourceFile = path.join(source, file);
-      const destFile = path.join(dest, file);
-
-      // Check if destination file exists
-      if (await fs.pathExists(destFile)) {
-        // Compare checksums to see if file has been modified
-        const sourceHash = await this.getFileHash(sourceFile);
-        const destHash = await this.getFileHash(destFile);
-
-        if (sourceHash === destHash) {
-          // Files are identical, safe to update
-          await fs.copy(sourceFile, destFile, { overwrite: true });
-        } else {
-          // File has been modified, check timestamps
-          const sourceStats = await fs.stat(sourceFile);
-          const destStats = await fs.stat(destFile);
-
-          if (sourceStats.mtime > destStats.mtime) {
-            // Source is newer, update
-            await fs.copy(sourceFile, destFile, { overwrite: true });
-          }
-          // Otherwise, preserve user modifications
-        }
-      } else {
-        // New file, copy it
-        await fs.ensureDir(path.dirname(destFile));
-        await fs.copy(sourceFile, destFile);
-      }
-    }
-
-    // Remove files that no longer exist in source
-    const destFiles = await this.getFileList(dest);
-    for (const file of destFiles) {
-      const sourceFile = path.join(source, file);
-      const destFile = path.join(dest, file);
-
-      if (!(await fs.pathExists(sourceFile))) {
-        await fs.remove(destFile);
-      }
-    }
-  }
-
-  /**
-   * Get list of all files in a directory
-   * @param {string} dir - Directory path
-   * @returns {Array} List of relative file paths
-   */
-  async getFileList(dir) {
-    const files = [];
-
-    if (!(await fs.pathExists(dir))) {
-      return files;
-    }
-
-    const walk = async (currentDir, baseDir) => {
-      const entries = await fs.readdir(currentDir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(currentDir, entry.name);
-
-        if (entry.isDirectory() && !this.shouldIgnore(fullPath)) {
-          await walk(fullPath, baseDir);
-        } else if (entry.isFile() && !this.shouldIgnore(fullPath)) {
-          files.push(path.relative(baseDir, fullPath));
-        }
-      }
-    };
-
-    await walk(dir, dir);
-    return files;
-  }
-
-  /**
-   * Get file hash for comparison
-   * @param {string} filePath - File path
-   * @returns {string} File hash
-   */
-  async getFileHash(filePath) {
-    const hash = crypto.createHash('sha256');
-    const stream = fs.createReadStream(filePath);
-
-    return new Promise((resolve, reject) => {
-      stream.on('data', (data) => hash.update(data));
-      stream.on('end', () => resolve(hash.digest('hex')));
-      stream.on('error', reject);
-    });
-  }
-
-  /**
-   * Check if a path should be ignored
-   * @param {string} filePath - Path to check
-   * @returns {boolean} True if should be ignored
-   */
-  shouldIgnore(filePath) {
-    const ignoredPatterns = ['.git', '.DS_Store', 'node_modules', '*.swp', '*.tmp', '.idea', '.vscode', '__pycache__', '*.pyc'];
-
-    const basename = path.basename(filePath);
-
-    for (const pattern of ignoredPatterns) {
-      if (pattern.includes('*')) {
-        // Simple glob pattern matching
-        const regex = new RegExp(pattern.replace('*', '.*'));
-        if (regex.test(basename)) {
-          return true;
-        }
-      } else if (basename === pattern) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Ensure directory exists
-   * @param {string} dir - Directory path
-   */
-  async ensureDir(dir) {
-    await fs.ensureDir(dir);
-  }
-
-  /**
-   * Remove directory or file
-   * @param {string} targetPath - Path to remove
-   */
-  async remove(targetPath) {
-    if (await fs.pathExists(targetPath)) {
-      await fs.remove(targetPath);
-    }
-  }
-
-  /**
-   * Read file content
-   * @param {string} filePath - File path
-   * @returns {string} File content
-   */
-  async readFile(filePath) {
-    return await fs.readFile(filePath, 'utf8');
-  }
-
-  /**
-   * Write file content
-   * @param {string} filePath - File path
-   * @param {string} content - File content
-   */
-  async writeFile(filePath, content) {
-    await fs.ensureDir(path.dirname(filePath));
-    await fs.writeFile(filePath, content, 'utf8');
-  }
-
-  /**
-   * Check if path exists
-   * @param {string} targetPath - Path to check
-   * @returns {boolean} True if exists
-   */
-  async exists(targetPath) {
-    return await fs.pathExists(targetPath);
-  }
-
-  /**
-   * Get file or directory stats
-   * @param {string} targetPath - Path to check
-   * @returns {Object} File stats
-   */
-  async stat(targetPath) {
-    return await fs.stat(targetPath);
-  }
-}
-
-module.exports = { FileOps };

package/tools/installer/ide/shared/skill-manifest.js

@@ -1,57 +0,0 @@
-const path = require('node:path');
-const fs = require('../../fs-native');
-const yaml = require('yaml');
-
-/**
- * Load wizz-skill-manifest.yaml from a directory.
- * Single-entry manifests (canonicalId at top level) apply to all files in the directory.
- * Multi-entry manifests are keyed by source filename.
- * @param {string} dirPath - Directory to check for wizz-skill-manifest.yaml
- * @returns {Object|null} Parsed manifest or null
- */
-async function loadSkillManifest(dirPath) {
-  const manifestPath = path.join(dirPath, 'wizz-skill-manifest.yaml');
-  try {
-    if (!(await fs.pathExists(manifestPath))) return null;
-    const content = await fs.readFile(manifestPath, 'utf8');
-    const parsed = yaml.parse(content);
-    if (!parsed || typeof parsed !== 'object') return null;
-    if (parsed.canonicalId || parsed.type) return { __single: parsed };
-    return parsed;
-  } catch (error) {
-    console.warn(`Warning: Failed to parse wizz-skill-manifest.yaml in ${dirPath}: ${error.message}`);
-    return null;
-  }
-}
-
-/**
- * Get the canonicalId for a specific file from a loaded skill manifest.
- * @param {Object|null} manifest - Loaded manifest (from loadSkillManifest)
- * @param {string} filename - Source filename to look up (e.g., 'pm.md', 'help.md')
- * @returns {string} canonicalId or empty string
- */
-function getCanonicalId(manifest, filename) {
-  if (!manifest) return '';
-  // Single-entry manifest applies to all files in the directory
-  if (manifest.__single) return manifest.__single.canonicalId || '';
-  // Multi-entry: look up by filename directly
-  if (manifest[filename]) return manifest[filename].canonicalId || '';
-  return '';
-}
-
-/**
- * Get the artifact type for a specific file from a loaded skill manifest.
- * @param {Object|null} manifest - Loaded manifest (from loadSkillManifest)
- * @param {string} filename - Source filename to look up
- * @returns {string|null} type or null
- */
-function getArtifactType(manifest, filename) {
-  if (!manifest) return null;
-  // Single-entry manifest applies to all files in the directory
-  if (manifest.__single) return manifest.__single.type || null;
-  // Multi-entry: look up by filename directly
-  if (manifest[filename]) return manifest[filename].type || null;
-  return null;
-}
-
-module.exports = { loadSkillManifest, getCanonicalId, getArtifactType };

package/tools/installer/yaml-format.js

@@ -1,245 +0,0 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const yaml = require('yaml');
-const { execSync } = require('node:child_process');
-
-// Dynamic import for ES module
-let chalk;
-
-// Initialize ES modules
-async function initializeModules() {
-  if (!chalk) {
-    chalk = (await import('chalk')).default;
-  }
-}
-
-/**
- * YAML Formatter and Linter for Wizz-Method
- * Formats and validates YAML files and YAML embedded in Markdown
- */
-
-async function formatYamlContent(content, filename) {
-  await initializeModules();
-  try {
-    // First try to fix common YAML issues
-    let fixedContent = content
-      // Fix "commands :" -> "commands:"
-      .replaceAll(/^(\s*)(\w+)\s+:/gm, '$1$2:')
-      // Fix inconsistent list indentation
-      .replaceAll(/^(\s*)-\s{3,}/gm, '$1- ');
-
-    // Skip auto-fixing for .roomodes files - they have special nested structure
-    if (!filename.includes('.roomodes')) {
-      fixedContent = fixedContent
-        // Fix unquoted list items that contain special characters or multiple parts
-        .replaceAll(/^(\s*)-\s+(.*)$/gm, (match, indent, content) => {
-          // Skip if already quoted
-          if (content.startsWith('"') && content.endsWith('"')) {
-            return match;
-          }
-          // If the content contains special YAML characters or looks complex, quote it
-          // BUT skip if it looks like a proper YAML key-value pair (like "key: value")
-          if (
-            (content.includes(':') || content.includes('-') || content.includes('{') || content.includes('}')) &&
-            !/^\w+:\s/.test(content)
-          ) {
-            // Remove any existing quotes first, escape internal quotes, then add proper quotes
-            const cleanContent = content.replaceAll(/^["']|["']$/g, '').replaceAll('"', String.raw`\"`);
-            return `${indent}- "${cleanContent}"`;
-          }
-          return match;
-        });
-    }
-
-    // Debug: show what we're trying to parse
-    if (fixedContent !== content) {
-      console.log(chalk.blue(`🔧 Applied YAML fixes to ${filename}`));
-    }
-
-    // Parse and re-dump YAML to format it
-    const parsed = yaml.parse(fixedContent);
-    const formatted = yaml.stringify(parsed, {
-      indent: 2,
-      lineWidth: 0, // Disable line wrapping
-      sortKeys: false, // Preserve key order
-    });
-    // Ensure POSIX-compliant final newline
-    return formatted.endsWith('\n') ? formatted : formatted + '\n';
-  } catch (error) {
-    console.error(chalk.red(`❌ YAML syntax error in ${filename}:`), error.message);
-    console.error(chalk.yellow(`💡 Try manually fixing the YAML structure first`));
-    return null;
-  }
-}
-
-async function processMarkdownFile(filePath) {
-  await initializeModules();
-  const content = fs.readFileSync(filePath, 'utf8');
-  let modified = false;
-  let newContent = content;
-
-  // Fix untyped code blocks by adding 'text' type
-  // Match ``` at start of line followed by newline, but only if it's an opening fence
-  newContent = newContent.replaceAll(/^```\n([\s\S]*?)\n```$/gm, '```text\n$1\n```');
-  if (newContent !== content) {
-    modified = true;
-    console.log(chalk.blue(`🔧 Added 'text' type to untyped code blocks in ${filePath}`));
-  }
-
-  // Find YAML code blocks
-  const yamlBlockRegex = /```ya?ml\n([\s\S]*?)\n```/g;
-  let match;
-  const replacements = [];
-
-  while ((match = yamlBlockRegex.exec(newContent)) !== null) {
-    const [fullMatch, yamlContent] = match;
-    const formatted = await formatYamlContent(yamlContent, filePath);
-    if (formatted !== null) {
-      const trimmedFormatted = formatted.replace(/\n$/, '');
-
-      if (trimmedFormatted !== yamlContent) {
-        modified = true;
-        console.log(chalk.green(`✓ Formatted YAML in ${filePath}`));
-      }
-
-      replacements.push({
-        start: match.index,
-        end: match.index + fullMatch.length,
-        replacement: `\`\`\`yaml\n${trimmedFormatted}\n\`\`\``,
-      });
-    }
-  }
-
-  // Apply replacements in reverse order to maintain indices
-  for (let index = replacements.length - 1; index >= 0; index--) {
-    const { start, end, replacement } = replacements[index];
-    newContent = newContent.slice(0, start) + replacement + newContent.slice(end);
-  }
-
-  if (modified) {
-    fs.writeFileSync(filePath, newContent);
-    return true;
-  }
-  return false;
-}
-
-async function processYamlFile(filePath) {
-  await initializeModules();
-  const content = fs.readFileSync(filePath, 'utf8');
-  const formatted = await formatYamlContent(content, filePath);
-
-  if (formatted === null) {
-    return false; // Syntax error
-  }
-
-  if (formatted !== content) {
-    fs.writeFileSync(filePath, formatted);
-    return true;
-  }
-  return false;
-}
-
-async function lintYamlFile(filePath) {
-  await initializeModules();
-  try {
-    // Use yaml-lint for additional validation
-    execSync(`npx yaml-lint "${filePath}"`, { stdio: 'pipe' });
-    return true;
-  } catch (error) {
-    console.error(chalk.red(`❌ YAML lint error in ${filePath}:`));
-    console.error(error.stdout?.toString() || error.message);
-    return false;
-  }
-}
-
-async function main() {
-  await initializeModules();
-  const arguments_ = process.argv.slice(2);
-  const glob = require('glob');
-
-  if (arguments_.length === 0) {
-    console.error('Usage: node yaml-format.js <file1> [file2] ...');
-    process.exit(1);
-  }
-
-  let hasErrors = false;
-  let hasChanges = false;
-  let filesProcessed = [];
-
-  // Expand glob patterns and collect all files
-  const allFiles = [];
-  for (const argument of arguments_) {
-    if (argument.includes('*')) {
-      // It's a glob pattern
-      const matches = glob.sync(argument);
-      allFiles.push(...matches);
-    } else {
-      // It's a direct file path
-      allFiles.push(argument);
-    }
-  }
-
-  for (const filePath of allFiles) {
-    if (!fs.existsSync(filePath)) {
-      // Skip silently for glob patterns that don't match anything
-      if (!arguments_.some((argument) => argument.includes('*') && filePath === argument)) {
-        console.error(chalk.red(`❌ File not found: ${filePath}`));
-        hasErrors = true;
-      }
-      continue;
-    }
-
-    const extension = path.extname(filePath).toLowerCase();
-    const basename = path.basename(filePath).toLowerCase();
-
-    try {
-      let changed = false;
-      if (extension === '.md') {
-        changed = await processMarkdownFile(filePath);
-      } else if (
-        extension === '.yaml' ||
-        extension === '.yml' ||
-        basename.includes('roomodes') ||
-        basename.includes('.yaml') ||
-        basename.includes('.yml')
-      ) {
-        // Handle YAML files and special cases like .roomodes
-        changed = await processYamlFile(filePath);
-
-        // Also run linting
-        const lintPassed = await lintYamlFile(filePath);
-        if (!lintPassed) hasErrors = true;
-      } else {
-        // Skip silently for unsupported files
-        continue;
-      }
-
-      if (changed) {
-        hasChanges = true;
-        filesProcessed.push(filePath);
-      }
-    } catch (error) {
-      console.error(chalk.red(`❌ Error processing ${filePath}:`), error.message);
-      hasErrors = true;
-    }
-  }
-
-  if (hasChanges) {
-    console.log(chalk.green(`\n✨ YAML formatting completed! Modified ${filesProcessed.length} files:`));
-    for (const file of filesProcessed) console.log(chalk.blue(`  📝 ${file}`));
-  }
-
-  if (hasErrors) {
-    console.error(chalk.red('\n💥 Some files had errors. Please fix them before committing.'));
-    process.exit(1);
-  }
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    console.error('Error:', error);
-    process.exit(1);
-  });
-}
-
-module.exports = { formatYamlContent, processMarkdownFile, processYamlFile };

package/web-bundles/README.md

@@ -1,46 +0,0 @@
-# Wizz Web Bundles
-
-V4 shipped web bundles. V6 brings them back, new and improved. Each bundle packages a Wizz skill as a self-contained install for **Google Gemini Gems** and **ChatGPT Custom GPTs**, so you can run the planning work in your web LLM subscription before opening your IDE.
-
-## Install
-
-**Go to [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/).**
-
-The site lists every bundle in a card grid, walks you through the Gemini and ChatGPT setup inline, and hands you the ZIP download in one click. That is the only supported install path.
-
-Why a single front door:
-
-- One place to keep install steps current as Gemini and ChatGPT evolve.
-- Versioned releases. Every shelf update ships as a tagged GitHub Release; the site always points at the newest tag.
-- One signup gets you on the list for new bundles as they ship.
-
-## Why use them
-
-- **Cost.** Web LLM subscriptions are flat-rate. Run brainstorming, briefs, PRDs, and research there instead of burning IDE tokens.
-- **Right tool for the job.** Planning conversations want Canvas, image generation, and Deep Research. Implementation wants the codebase and a terminal. Use each where it's strongest.
-- **Persona swapping.** Every bundle ships a default persona and a contrasting swap example. Change voices without touching the protocol.
-
-## The shelf
-
-| Bundle | Purpose |
-| --- | --- |
-| Brainstorming Coach | Facilitated ideation across 60 techniques. Defaults to **Carson** (Osborn lineage); swap to **Mary** for analyst rigor. |
-| Product Brief Coach | Build a product brief through guided discovery. Create, Update, or Validate modes. |
-| PRFAQ Coach | Working Backwards PRFAQ challenge (Bezos lineage) to forge and stress-test product concepts. |
-| PRD Coach | Product Requirements Document with built-in validation (Cagan lineage). |
-| UX Coach | UX patterns, flows, and design specifications. Pairs with Google Stitch. |
-| Market & Industry Research | Market research, customer JTBD, competitive landscape, regulatory and technical lenses. Deep Research mode integrated. |
-
-Requires Gemini Advanced (for Gems) or ChatGPT Plus / Pro / Business / Enterprise (for Custom GPTs). Deep Research has its own plan limits.
-
-## Build your own
-
-Web bundles are generated from Wizz skills using the [`bmad-os-skill-to-bundle`](https://github.com/bmad-code-org/wizz-utility-skills) utility skill. Point it at any Wizz skill folder and it produces a `SKILL.md`, an `INSTRUCTIONS.md`, and any required data files, with persona inheritance from the owning agent.
-
-## What's in this folder
-
-This folder is the **source** for the shelf, packaged into ZIPs and attached to GitHub Releases. End users do not install from here. If you are a contributor working on a bundle, the bundle directories and `bundles.json` are the files you edit; the [release packager](../tools/bundle-web-bundles.js) zips them and updates the release.
-
-## Concept docs
-
-[What web bundles are and when to use them](https://docs.wizz-method.org/explanation/web-bundles/).

package/web-bundles/brainstorming-coach/INSTRUCTIONS.md

@@ -1,86 +0,0 @@
-# Brainstorming Coach Setup
-
-## Install (Gemini Gem)
-
-1. Create a Gem named **Brainstorming Coach**.
-2. Upload `SKILL.md` and `brain-methods.csv` as knowledge files.
-3. Paste everything below the **PASTE BOUNDARY** line into the instructions box.
-4. Save.
-
-## Install (ChatGPT Custom GPT)
-
-1. Create a GPT named **Brainstorming Coach**.
-2. Under **Configure**, upload `SKILL.md` and `brain-methods.csv` as **Knowledge**.
-3. Paste everything below the **PASTE BOUNDARY** line into **Instructions**.
-4. Turn **Web Browsing** ON (the protocol uses it to verify current references).
-5. Save.
-
-## Customize
-
-Edit the `[persona]` block below to swap voices. Default: **Carson, Elite Brainstorming Specialist**. `[preferences]` sets a default user name.
-
-## Persona Swap Example (reference, do not paste)
-
-**Mary, Strategic Business Analyst**: more rigorous, less improv; tuned for software planning.
-
-```
-name: Mary
-title: Strategic Business Analyst
-icon: 📊
-role: |
-  Help the user ideate, research, and analyze before committing to a project in the Wizz Method analysis phase. Facilitate brainstorming as structured discovery without generating ideas for the user.
-identity: |
-  Senior analyst with a research-first instinct. Treats brainstorming as structured discovery, prizes evidence and pattern recognition, hunts for the assumption hiding under every idea.
-communication_style: |
-  Precise, curious, slightly skeptical. Asks "what would have to be true?" more than "what if?" Celebrates rigor over volume.
-principles:
-  - Every idea contains an assumption worth surfacing.
-  - The map is not the territory; the brainstorm is not the strategy.
-  - Pattern recognition beats brute-force ideation.
-suggested_focus: |
-  Software product planning and the fuzzy front end of building things: feature scoping, requirements discovery, user-problem framing, competitive positioning, project briefs, architecture trade-offs, pre-PRD shaping. Strongest where the right framing changes what gets built. Mention this focus in the opener as an invitation, not a constraint; the user may steer anywhere.
-```
-
-Swap the `[persona]` block below with the alternative or invent your own. Protocol stays the same; voice transforms.
-
-
-═══════════════════════════════════════════════════════════════════════
-▼▼▼   PASTE BOUNDARY: PASTE EVERYTHING BELOW INTO INSTRUCTIONS   ▼▼▼
-═══════════════════════════════════════════════════════════════════════
-
-
-You are a brainstorming facilitator. Your identity is in the `[persona]` block below; your protocol is in your knowledge file `SKILL.md`; your technique library is in `brain-methods.csv`.
-
-On the first user message, read `SKILL.md` in full from your knowledge files, then greet the user as the persona and begin the session opener described in the protocol. Stay in character until the user dismisses the persona.
-
-## [persona]
-
-```
-name: Carson
-title: Elite Brainstorming Specialist
-icon: 🧠
-
-role: |
-  Facilitate brainstorming sessions that pull novel ideas out of the user using the 60 techniques in the brain-methods library. Never generate ideas for the user; your craft is the framing, the questions, and the polish.
-
-identity: |
-  Twenty years leading breakthrough sessions. Channels Alex Osborn's brainstorming foundations and Keith Johnstone's improv-born yes-and instinct. Fluent in group dynamics and the art of making it safe to say the ridiculous thing out loud.
-
-communication_style: |
-  Enthusiastic improv coach. High-energy, YES AND everything, celebrates the wildest thinking in the room. Warm, playful, never sarcastic.
-
-principles:
-  - Psychological safety unlocks breakthroughs. No idea gets judged until it has had room to breathe.
-  - Wild ideas today become obvious innovations tomorrow.
-  - Humor and play are serious innovation tools.
-
-suggested_focus: |
-  Creative innovation and breakthrough thinking across any domain: opportunity exploration, novel product or service concepts, naming and branding, campaign and story ideation, reframing stuck problems, what-if futures, inventing new categories, and the kind of wild divergence that makes the obvious answer look small. Strongest when the goal is more, weirder, and bolder. Mention this focus in the opener as an invitation, not a constraint; the user may steer anywhere.
-```
-
-## [preferences]
-
-```
-user_name: ""
-# Optional. Blank means the coach asks once at session start.
-```