namnam-skills 1.0.0

package/src/cli.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const program = new Command();
+
+// ASCII Art Banner
+const banner = `
+${chalk.cyan('╔══════════════════════════════════════════════════════════════╗')}
+${chalk.cyan('║')}  ${chalk.yellow.bold('NAMNAM SKILLS')}                                                ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.gray('Universal AI Skills Installer')}                                ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.green('Claude • Codex • Cursor • Windsurf • Cline • Aider')}           ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.magenta('150+ Agents | Workflows | Industry Prompts')}                  ${chalk.cyan('║')}
+${chalk.cyan('╚══════════════════════════════════════════════════════════════╝')}
+`;
+
+// Skill categories
+const SKILL_CATEGORIES = {
+  core: {
+    name: 'Core Skills',
+    description: 'Essential: /namnam orchestrator, git, code-review, validate-and-fix',
+    folder: 'core'
+  },
+  platforms: {
+    name: 'AI Platforms Config',
+    description: 'Cursor, Windsurf, Cline, Codex, Aider, Gemini templates + AGENTS.md',
+    folder: 'platforms'
+  },
+  official_plugins: {
+    name: 'Official Anthropic Plugins',
+    description: 'feature-dev, commit, PR review, hookify, security, ralph-loop, frontend-design (11 files)',
+    folder: 'official-plugins'
+  },
+  vercel: {
+    name: 'Vercel Skills',
+    description: 'React best practices (51 rules), web design guidelines',
+    folder: 'vercel-skills'
+  },
+  claudekit: {
+    name: 'ClaudeKit',
+    description: 'Oracle, triage-expert, research-expert, code-search, checkpoints',
+    folder: 'claudekit'
+  },
+  bmad_bmm: {
+    name: 'BMAD BMM (Business Method)',
+    description: 'Business analysis, architecture, PRD, sprint planning workflows',
+    folder: 'bmad/bmm'
+  },
+  bmad_bmgd: {
+    name: 'BMAD BMGD (Game Development)',
+    description: 'Game design, GDD, game architecture, testing workflows',
+    folder: 'bmad/bmgd'
+  },
+  bmad_cis: {
+    name: 'BMAD CIS (Creative Innovation)',
+    description: 'Brainstorming, design thinking, innovation, storytelling',
+    folder: 'bmad/cis'
+  },
+  bmad_bmb: {
+    name: 'BMAD BMB (Builder)',
+    description: 'Agent builder, module builder, workflow builder',
+    folder: 'bmad/bmb'
+  },
+  bmad_core: {
+    name: 'BMAD Core',
+    description: 'BMAD master agent, brainstorming, party mode',
+    folder: 'bmad/core'
+  },
+  cursor_rules: {
+    name: 'Cursor Rules Collection',
+    description: 'Expert rules: TypeScript, Python, React Native, Vue, Solidity, Go, Rust, DevOps',
+    folder: 'cursor-rules'
+  },
+  system_prompts: {
+    name: 'System Prompts Collection',
+    description: 'Industry best practices from 30+ AI tools: Claude Code, Cursor, Windsurf, Cline, Antigravity',
+    folder: 'system-prompts'
+  },
+  all: {
+    name: 'All Skills',
+    description: 'Install EVERYTHING - 150+ skills, agents, workflows, and platform configs',
+    folder: '*'
+  }
+};
+
+// Supported AI Platforms
+const AI_PLATFORMS = {
+  claude: { file: '.claude/', name: 'Claude Code' },
+  cursor: { file: '.cursorrules', name: 'Cursor' },
+  windsurf: { file: '.windsurfrules', name: 'Windsurf' },
+  cline: { file: '.clinerules', name: 'Cline' },
+  aider: { file: '.aider.conf.yml', name: 'Aider' },
+  codex: { file: 'codex.md', name: 'OpenAI Codex' },
+  gemini: { file: 'GEMINI.md', name: 'Google Gemini' },
+  universal: { file: 'AGENTS.md', name: 'Universal (All Platforms)' }
+};
+
+program
+  .name('namnam')
+  .description('Universal AI Skills Installer - Supports Claude, Codex, Cursor, Windsurf, Cline, Aider, Gemini')
+  .version('2.0.0');
+
+program
+  .command('init')
+  .description('Initialize AI skills in current project')
+  .option('-a, --all', 'Install all skills and platform configs')
+  .option('-c, --category <category>', 'Install specific category')
+  .option('-i, --interactive', 'Interactive mode - choose what to install')
+  .option('-f, --force', 'Overwrite existing files')
+  .option('-p, --platforms', 'Also generate platform config files (.cursorrules, etc.)')
+  .action(async (options) => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+    const claudeDir = path.join(cwd, '.claude', 'commands');
+
+    // Check if .claude directory exists
+    const hasClaudeDir = await fs.pathExists(path.join(cwd, '.claude'));
+
+    if (!hasClaudeDir) {
+      console.log(chalk.yellow('\n⚠️  No .claude directory found. Creating one...\n'));
+    }
+
+    let selectedCategories = [];
+    let generatePlatformConfigs = options.platforms || false;
+
+    if (options.interactive) {
+      // Interactive mode
+      const answers = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'categories',
+          message: 'Select skill categories to install:',
+          choices: Object.entries(SKILL_CATEGORIES).map(([key, value]) => ({
+            name: `${chalk.cyan(value.name)} - ${chalk.gray(value.description)}`,
+            value: key,
+            checked: key === 'core' || key === 'platforms'
+          }))
+        },
+        {
+          type: 'confirm',
+          name: 'generateConfigs',
+          message: 'Generate platform config files (.cursorrules, .windsurfrules, etc.)?',
+          default: true
+        }
+      ]);
+      selectedCategories = answers.categories;
+      generatePlatformConfigs = answers.generateConfigs;
+    } else if (options.all) {
+      selectedCategories = ['all'];
+      generatePlatformConfigs = true;
+    } else if (options.category) {
+      if (!SKILL_CATEGORIES[options.category]) {
+        console.log(chalk.red(`\n❌ Unknown category: ${options.category}`));
+        console.log(chalk.gray('Available categories:'), Object.keys(SKILL_CATEGORIES).join(', '));
+        process.exit(1);
+      }
+      selectedCategories = [options.category];
+    } else {
+      // Default: install core + platforms
+      selectedCategories = ['core', 'platforms'];
+      console.log(chalk.cyan('\n📦 Installing core skills and platform configs...\n'));
+      console.log(chalk.gray('Tip: Use --interactive for more options, or --all for everything\n'));
+    }
+
+    const spinner = ora('Installing skills...').start();
+
+    try {
+      // Create .claude/commands directory
+      await fs.ensureDir(claudeDir);
+
+      // Copy templates
+      const templatesDir = path.join(__dirname, 'templates');
+      let copiedCount = 0;
+
+      if (selectedCategories.includes('all')) {
+        // Copy everything
+        const folders = ['core', 'platforms', 'official-plugins', 'vercel-skills', 'claudekit', 'bmad', 'cursor-rules', 'system-prompts'];
+        for (const folder of folders) {
+          const srcDir = path.join(templatesDir, folder);
+          if (await fs.pathExists(srcDir)) {
+            await fs.copy(srcDir, path.join(claudeDir, folder), { overwrite: options.force });
+            copiedCount += await countFiles(srcDir);
+          }
+        }
+      } else {
+        // Copy selected categories
+        for (const category of selectedCategories) {
+          const catConfig = SKILL_CATEGORIES[category];
+          if (!catConfig) continue;
+
+          const srcDir = path.join(templatesDir, catConfig.folder);
+          if (await fs.pathExists(srcDir)) {
+            const destDir = path.join(claudeDir, catConfig.folder);
+            await fs.copy(srcDir, destDir, { overwrite: options.force });
+            copiedCount += await countFiles(srcDir);
+          }
+        }
+      }
+
+      spinner.succeed(chalk.green(`Successfully installed ${copiedCount} skill files!`));
+
+      // Generate platform config files if requested
+      if (generatePlatformConfigs) {
+        console.log(chalk.cyan('\n📝 Generating platform config files...'));
+        await generatePlatformFiles(cwd, templatesDir, options.force);
+      }
+
+      // Summary
+      console.log(chalk.cyan('\n✨ Skills installed to: .claude/commands/'));
+      console.log(chalk.white('\nInstalled categories:'));
+      for (const cat of selectedCategories) {
+        const config = SKILL_CATEGORIES[cat];
+        if (config) {
+          console.log(chalk.gray(`  • ${config.name}`));
+        }
+      }
+
+      console.log(chalk.cyan('\n🚀 Quick Start:'));
+      console.log(chalk.white('   /namnam <task>              - Orchestrate all agents'));
+      console.log(chalk.white('   /namnam --full <task>       - Maximum power mode'));
+      console.log(chalk.white('   /namnam --multi-platform    - Sync all AI configs'));
+      console.log(chalk.white('   /code-review                - Multi-aspect code review'));
+      console.log(chalk.white('   /validate-and-fix           - Run checks and auto-fix'));
+
+      console.log(chalk.magenta('\n🤖 Supported AI Platforms:'));
+      console.log(chalk.white('   Claude Code, Codex, Cursor, Windsurf, Cline, Aider, Gemini'));
+
+    } catch (error) {
+      spinner.fail(chalk.red('Installation failed!'));
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('platforms')
+  .description('Generate config files for all AI platforms')
+  .option('-f, --force', 'Overwrite existing files')
+  .action(async (options) => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+    const templatesDir = path.join(__dirname, 'templates');
+
+    console.log(chalk.cyan('\n📝 Generating platform config files...\n'));
+    await generatePlatformFiles(cwd, templatesDir, options.force);
+
+    console.log(chalk.green('\n✅ Platform configs generated!'));
+    console.log(chalk.gray('\nFiles created:'));
+    for (const [key, platform] of Object.entries(AI_PLATFORMS)) {
+      const filePath = path.join(cwd, platform.file);
+      const exists = await fs.pathExists(filePath);
+      if (exists) {
+        console.log(chalk.white(`  • ${platform.file} (${platform.name})`));
+      }
+    }
+  });
+
+program
+  .command('list')
+  .description('List all available skill categories')
+  .action(() => {
+    console.log(banner);
+    console.log(chalk.cyan('\n📚 Available Skill Categories:\n'));
+
+    Object.entries(SKILL_CATEGORIES).forEach(([key, value]) => {
+      console.log(chalk.yellow(`  ${key}`));
+      console.log(chalk.white(`    ${value.name}`));
+      console.log(chalk.gray(`    ${value.description}`));
+      console.log();
+    });
+
+    console.log(chalk.magenta('\n🤖 Supported AI Platforms:\n'));
+    Object.entries(AI_PLATFORMS).forEach(([key, value]) => {
+      console.log(chalk.white(`  ${value.name}`), chalk.gray(`(${value.file})`));
+    });
+
+    console.log(chalk.cyan('\nUsage:'));
+    console.log(chalk.white('  npx namnam-skills init --category <category>'));
+    console.log(chalk.white('  npx namnam-skills init --all'));
+    console.log(chalk.white('  npx namnam-skills init --interactive'));
+    console.log(chalk.white('  npx namnam-skills platforms'));
+  });
+
+program
+  .command('update')
+  .description('Update skills to latest version')
+  .action(async () => {
+    console.log(banner);
+    const spinner = ora('Checking for updates...').start();
+
+    spinner.info('Update functionality coming soon!');
+    console.log(chalk.gray('\nFor now, run: npm update -g namnam-skills'));
+  });
+
+program
+  .command('uninstall')
+  .description('Remove all installed skills')
+  .action(async () => {
+    console.log(banner);
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Are you sure you want to remove all skills?',
+        default: false
+      }
+    ]);
+
+    if (answers.confirm) {
+      const spinner = ora('Removing skills...').start();
+      const cwd = process.cwd();
+      const claudeDir = path.join(cwd, '.claude', 'commands');
+
+      try {
+        await fs.remove(claudeDir);
+        spinner.succeed(chalk.green('Skills removed successfully!'));
+      } catch (error) {
+        spinner.fail(chalk.red('Failed to remove skills'));
+        console.error(error.message);
+      }
+    }
+  });
+
+program
+  .command('info')
+  .description('Show information about installed skills and detected platforms')
+  .action(async () => {
+    console.log(banner);
+
+    const cwd = process.cwd();
+    const claudeDir = path.join(cwd, '.claude', 'commands');
+
+    // Detect AI platforms
+    console.log(chalk.magenta('\n🤖 Detected AI Platforms:\n'));
+    for (const [key, platform] of Object.entries(AI_PLATFORMS)) {
+      const filePath = path.join(cwd, platform.file);
+      const exists = await fs.pathExists(filePath);
+      const status = exists ? chalk.green('✓') : chalk.gray('○');
+      console.log(`  ${status} ${platform.name} (${platform.file})`);
+    }
+
+    // Skills info
+    if (!(await fs.pathExists(claudeDir))) {
+      console.log(chalk.yellow('\n⚠️  No skills installed. Run `namnam init` to install.'));
+      return;
+    }
+
+    const count = await countFiles(claudeDir);
+    console.log(chalk.green(`\n✅ ${count} skill files installed`));
+    console.log(chalk.gray(`   Location: ${claudeDir}`));
+
+    // List folders
+    const items = await fs.readdir(claudeDir, { withFileTypes: true });
+    const folders = items.filter(i => i.isDirectory()).map(i => i.name);
+
+    if (folders.length > 0) {
+      console.log(chalk.cyan('\nInstalled categories:'));
+      for (const folder of folders) {
+        const folderPath = path.join(claudeDir, folder);
+        const folderCount = await countFiles(folderPath);
+        console.log(chalk.white(`  • ${folder} (${folderCount} files)`));
+      }
+    }
+  });
+
+// Helper function to count files recursively
+async function countFiles(dir) {
+  let count = 0;
+
+  if (!(await fs.pathExists(dir))) {
+    return 0;
+  }
+
+  const items = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const item of items) {
+    if (item.isDirectory()) {
+      count += await countFiles(path.join(dir, item.name));
+    } else if (item.name.endsWith('.md') || item.name.endsWith('.yml') || item.name.endsWith('.json')) {
+      count++;
+    }
+  }
+
+  return count;
+}
+
+// Generate platform config files
+async function generatePlatformFiles(cwd, templatesDir, force = false) {
+  const platformsDir = path.join(templatesDir, 'platforms');
+
+  // Copy AGENTS.md to project root
+  const agentsSrc = path.join(platformsDir, 'AGENTS.md');
+  const agentsDest = path.join(cwd, 'AGENTS.md');
+  if (await fs.pathExists(agentsSrc)) {
+    if (force || !(await fs.pathExists(agentsDest))) {
+      await fs.copy(agentsSrc, agentsDest);
+      console.log(chalk.green('  ✓ AGENTS.md (Universal)'));
+    }
+  }
+
+  // Generate .cursorrules
+  const cursorSrc = path.join(platformsDir, 'cursor', 'cursorrules-template.md');
+  const cursorDest = path.join(cwd, '.cursorrules');
+  if (await fs.pathExists(cursorSrc)) {
+    if (force || !(await fs.pathExists(cursorDest))) {
+      const content = await fs.readFile(cursorSrc, 'utf-8');
+      // Extract the rules content from the markdown
+      const match = content.match(/```[\s\S]*?```/);
+      if (match) {
+        const rules = match[0].replace(/```/g, '').trim();
+        await fs.writeFile(cursorDest, rules);
+        console.log(chalk.green('  ✓ .cursorrules (Cursor)'));
+      }
+    }
+  }
+
+  // Generate .windsurfrules
+  const windsurfSrc = path.join(platformsDir, 'windsurf', 'windsurfrules-template.md');
+  const windsurfDest = path.join(cwd, '.windsurfrules');
+  if (await fs.pathExists(windsurfSrc)) {
+    if (force || !(await fs.pathExists(windsurfDest))) {
+      const content = await fs.readFile(windsurfSrc, 'utf-8');
+      const match = content.match(/```[\s\S]*?```/);
+      if (match) {
+        const rules = match[0].replace(/```/g, '').trim();
+        await fs.writeFile(windsurfDest, rules);
+        console.log(chalk.green('  ✓ .windsurfrules (Windsurf)'));
+      }
+    }
+  }
+
+  // Generate .clinerules
+  const clineSrc = path.join(platformsDir, 'cline', 'clinerules-template.md');
+  const clineDest = path.join(cwd, '.clinerules');
+  if (await fs.pathExists(clineSrc)) {
+    if (force || !(await fs.pathExists(clineDest))) {
+      const content = await fs.readFile(clineSrc, 'utf-8');
+      const match = content.match(/```yaml[\s\S]*?```/);
+      if (match) {
+        const rules = match[0].replace(/```yaml/g, '').replace(/```/g, '').trim();
+        await fs.writeFile(clineDest, rules);
+        console.log(chalk.green('  ✓ .clinerules (Cline)'));
+      }
+    }
+  }
+}
+
+program.parse();

package/src/index.js

@@ -0,0 +1 @@
+export { default } from './cli.js';

package/src/postinstall.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Find the actual project root (where user ran npm install)
+function findProjectRoot() {
+  // npm sets INIT_CWD to the directory where npm install was run
+  if (process.env.INIT_CWD) {
+    return process.env.INIT_CWD;
+  }
+
+  // Fallback: navigate from current directory
+  let current = process.cwd();
+
+  // If we're in node_modules, go to parent
+  if (current.includes('node_modules')) {
+    const parts = current.split(path.sep + 'node_modules');
+    current = parts[0];
+  }
+
+  return current;
+}
+
+async function autoInstall() {
+  const projectRoot = findProjectRoot();
+  const silent = process.env.NAMNAM_SILENT === 'true' || process.env.CI === 'true';
+
+  // Don't run during npm publish or in the package itself
+  if (process.env.npm_lifecycle_event === 'prepublishOnly') return;
+  if (projectRoot.includes('namnam-cli') || projectRoot.includes('namnam-skills')) return;
+
+  const claudeDir = path.join(projectRoot, '.claude', 'commands');
+  const templatesDir = path.join(__dirname, 'templates');
+
+  if (!silent) {
+    console.log(chalk.cyan('\n╔══════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan('║') + '  ' + chalk.yellow.bold('NAMNAM SKILLS') + ' - Auto Installing...                         ' + chalk.cyan('║'));
+    console.log(chalk.cyan('╚══════════════════════════════════════════════════════════════╝\n'));
+  }
+
+  const results = { success: 0, failed: 0 };
+
+  try {
+    // Create .claude/commands directory
+    await fs.ensureDir(claudeDir);
+
+    // Copy ALL templates with per-folder error handling
+    const folders = ['core', 'platforms', 'official-plugins', 'vercel-skills', 'claudekit', 'bmad', 'cursor-rules'];
+
+    for (const folder of folders) {
+      try {
+        const srcDir = path.join(templatesDir, folder);
+        if (await fs.pathExists(srcDir)) {
+          await fs.copy(srcDir, path.join(claudeDir, folder), { overwrite: true });
+          results.success += await countFiles(srcDir);
+        }
+      } catch (error) {
+        results.failed++;
+        if (!silent) {
+          console.log(chalk.yellow(`⚠️  Skipped ${folder}: ${error.message}`));
+        }
+      }
+    }
+
+    // Generate platform config files
+    try {
+      await generatePlatformFiles(projectRoot, templatesDir);
+    } catch (error) {
+      if (!silent) {
+        console.log(chalk.yellow(`⚠️  Some platform configs skipped: ${error.message}`));
+      }
+    }
+
+    if (!silent) {
+      if (results.success > 0) {
+        console.log(chalk.green(`✅ Installed ${results.success}+ skill files to .claude/commands/`));
+        console.log(chalk.green('✅ Generated platform configs (AGENTS.md, .cursorrules, etc.)'));
+        console.log(chalk.cyan('\n🚀 Quick Start:'));
+        console.log(chalk.white('   /namnam <task>              - Orchestrate all agents'));
+        console.log(chalk.white('   /namnam --full <task>       - Maximum power mode'));
+        console.log(chalk.white('   /code-review                - Multi-aspect code review'));
+        console.log(chalk.white('   /validate-and-fix           - Run checks and auto-fix\n'));
+      }
+      if (results.failed > 0) {
+        console.log(chalk.yellow(`\n⚠️  ${results.failed} folders skipped. Run manually: npx namnam-skills init --all`));
+      }
+    }
+
+  } catch (error) {
+    // Silent fail - don't break user's install
+    if (!silent) {
+      console.log(chalk.yellow('⚠️  Auto-install skipped. Run manually: npx namnam-skills init --all'));
+    }
+  }
+}
+
+async function countFiles(dir) {
+  let count = 0;
+  if (!(await fs.pathExists(dir))) return 0;
+
+  const items = await fs.readdir(dir, { withFileTypes: true });
+  for (const item of items) {
+    if (item.isDirectory()) {
+      count += await countFiles(path.join(dir, item.name));
+    } else if (item.name.endsWith('.md') || item.name.endsWith('.yml') || item.name.endsWith('.json')) {
+      count++;
+    }
+  }
+  return count;
+}
+
+async function generatePlatformFiles(projectRoot, templatesDir) {
+  const platformsDir = path.join(templatesDir, 'platforms');
+
+  // Copy AGENTS.md (always overwrite for updates)
+  const agentsSrc = path.join(platformsDir, 'AGENTS.md');
+  const agentsDest = path.join(projectRoot, 'AGENTS.md');
+  if (await fs.pathExists(agentsSrc)) {
+    await fs.copy(agentsSrc, agentsDest, { overwrite: true });
+  }
+
+  // Generate .cursorrules
+  const cursorSrc = path.join(platformsDir, 'cursor', 'cursorrules-template.md');
+  const cursorDest = path.join(projectRoot, '.cursorrules');
+  if (await fs.pathExists(cursorSrc) && !(await fs.pathExists(cursorDest))) {
+    const content = await fs.readFile(cursorSrc, 'utf-8');
+    const match = content.match(/```[\s\S]*?```/);
+    if (match) {
+      await fs.writeFile(cursorDest, match[0].replace(/```/g, '').trim());
+    }
+  }
+
+  // Generate .windsurfrules
+  const windsurfSrc = path.join(platformsDir, 'windsurf', 'windsurfrules-template.md');
+  const windsurfDest = path.join(projectRoot, '.windsurfrules');
+  if (await fs.pathExists(windsurfSrc) && !(await fs.pathExists(windsurfDest))) {
+    const content = await fs.readFile(windsurfSrc, 'utf-8');
+    const match = content.match(/```[\s\S]*?```/);
+    if (match) {
+      await fs.writeFile(windsurfDest, match[0].replace(/```/g, '').trim());
+    }
+  }
+
+  // Generate .clinerules
+  const clineSrc = path.join(platformsDir, 'cline', 'clinerules-template.md');
+  const clineDest = path.join(projectRoot, '.clinerules');
+  if (await fs.pathExists(clineSrc) && !(await fs.pathExists(clineDest))) {
+    const content = await fs.readFile(clineSrc, 'utf-8');
+    const match = content.match(/```yaml[\s\S]*?```/);
+    if (match) {
+      await fs.writeFile(clineDest, match[0].replace(/```yaml/g, '').replace(/```/g, '').trim());
+    }
+  }
+}
+
+autoInstall();

package/src/templates/bmad/bmb/agents/agent-builder.md

@@ -0,0 +1,14 @@
+---
+name: 'agent-builder'
+description: 'agent-builder agent'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @_bmad/bmb/agents/agent-builder.md
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. Execute ALL activation steps exactly as written in the agent file
+4. Follow the agent's persona and menu system precisely
+5. Stay in character throughout the session
+</agent-activation>

package/src/templates/bmad/bmb/agents/module-builder.md

@@ -0,0 +1,14 @@
+---
+name: 'module-builder'
+description: 'module-builder agent'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @_bmad/bmb/agents/module-builder.md
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. Execute ALL activation steps exactly as written in the agent file
+4. Follow the agent's persona and menu system precisely
+5. Stay in character throughout the session
+</agent-activation>

package/src/templates/bmad/bmb/agents/workflow-builder.md

@@ -0,0 +1,14 @@
+---
+name: 'workflow-builder'
+description: 'workflow-builder agent'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @_bmad/bmb/agents/workflow-builder.md
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. Execute ALL activation steps exactly as written in the agent file
+4. Follow the agent's persona and menu system precisely
+5. Stay in character throughout the session
+</agent-activation>

package/src/templates/bmad/bmb/workflows/agent.md

@@ -0,0 +1,5 @@
+---
+description: 'Tri-modal workflow for creating, editing, and validating BMAD Core compliant agents'
+---
+
+IT IS CRITICAL THAT YOU FOLLOW THIS COMMAND: LOAD the FULL @_bmad/bmb/workflows/agent/workflow.md, READ its entire contents and follow its directions exactly!

package/src/templates/bmad/bmb/workflows/module.md

@@ -0,0 +1,5 @@
+---
+description: 'Quad-modal workflow for creating BMAD modules (Brief + Create + Edit + Validate)'
+---
+
+IT IS CRITICAL THAT YOU FOLLOW THIS COMMAND: LOAD the FULL @_bmad/bmb/workflows/module/workflow.md, READ its entire contents and follow its directions exactly!