bmad-method 6.0.0-alpha.9 → 6.0.1

package/tools/migrate-custom-module-paths.js

@@ -0,0 +1,124 @@
+/**
+ * Migration script to convert relative paths to absolute paths in custom module manifests
+ * This should be run once to update existing installations
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('yaml');
+const chalk = require('chalk');
+
+/**
+ * Find BMAD directory in project
+ */
+function findBmadDir(projectDir = process.cwd()) {
+  const possibleNames = ['_bmad'];
+
+  for (const name of possibleNames) {
+    const bmadDir = path.join(projectDir, name);
+    if (fs.existsSync(bmadDir)) {
+      return bmadDir;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Update manifest to use absolute paths
+ */
+async function updateManifest(manifestPath, projectRoot) {
+  console.log(chalk.cyan(`\nUpdating manifest: ${manifestPath}`));
+
+  const content = await fs.readFile(manifestPath, 'utf8');
+  const manifest = yaml.parse(content);
+
+  if (!manifest.customModules || manifest.customModules.length === 0) {
+    console.log(chalk.dim('  No custom modules found'));
+    return false;
+  }
+
+  let updated = false;
+
+  for (const customModule of manifest.customModules) {
+    if (customModule.relativePath && !customModule.sourcePath) {
+      // Convert relative path to absolute
+      const absolutePath = path.resolve(projectRoot, customModule.relativePath);
+      customModule.sourcePath = absolutePath;
+
+      // Remove the old relativePath
+      delete customModule.relativePath;
+
+      console.log(chalk.green(`  ✓ Updated ${customModule.id}: ${customModule.relativePath} → ${absolutePath}`));
+      updated = true;
+    } else if (customModule.sourcePath && !path.isAbsolute(customModule.sourcePath)) {
+      // Source path exists but is not absolute
+      const absolutePath = path.resolve(customModule.sourcePath);
+      customModule.sourcePath = absolutePath;
+
+      console.log(chalk.green(`  ✓ Updated ${customModule.id}: ${customModule.sourcePath} → ${absolutePath}`));
+      updated = true;
+    }
+  }
+
+  if (updated) {
+    // Write back the updated manifest
+    const yamlStr = yaml.dump(manifest, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true,
+      sortKeys: false,
+    });
+
+    await fs.writeFile(manifestPath, yamlStr);
+    console.log(chalk.green('  Manifest updated successfully'));
+  } else {
+    console.log(chalk.dim('  All paths already absolute'));
+  }
+
+  return updated;
+}
+
+/**
+ * Main migration function
+ */
+async function migrate(directory) {
+  const projectRoot = path.resolve(directory || process.cwd());
+  const bmadDir = findBmadDir(projectRoot);
+
+  if (!bmadDir) {
+    console.error(chalk.red('✗ No BMAD installation found in directory'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue.bold('🔄 BMAD Custom Module Path Migration'));
+  console.log(chalk.dim(`Project: ${projectRoot}`));
+  console.log(chalk.dim(`BMAD Directory: ${bmadDir}`));
+
+  const manifestPath = path.join(bmadDir, '_config', 'manifest.yaml');
+
+  if (!fs.existsSync(manifestPath)) {
+    console.error(chalk.red('✗ No manifest.yaml found'));
+    process.exit(1);
+  }
+
+  const updated = await updateManifest(manifestPath, projectRoot);
+
+  if (updated) {
+    console.log(chalk.green.bold('\n✨ Migration completed successfully!'));
+    console.log(chalk.dim('Custom modules now use absolute source paths.'));
+  } else {
+    console.log(chalk.yellow('\n⚠ No migration needed - paths already absolute'));
+  }
+}
+
+// Run migration if called directly
+if (require.main === module) {
+  const directory = process.argv[2];
+  migrate(directory).catch((error) => {
+    console.error(chalk.red('\n✗ Migration failed:'), error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { migrate };

package/tools/platform-codes.yaml

@@ -55,6 +55,24 @@ platforms:
     category: ide
     description: "Enhanced Cline fork"
 
+  rovo:
+    name: "Rovo"
+    preferred: false
+    category: ide
+    description: "Atlassian's AI coding assistant"
+
+  rovo-dev:
+    name: "Rovo Dev"
+    preferred: false
+    category: ide
+    description: "Atlassian's Rovo development environment"
+
+  kiro:
+    name: "Kiro"
+    preferred: false
+    category: ide
+    description: "Amazon's AI-powered IDE"
+
   github-copilot:
     name: "GitHub Copilot"
     preferred: false
@@ -97,6 +115,12 @@ platforms:
     category: ide
     description: "AI development assistant"
 
+  antigravity:
+    name: "Google Antigravity"
+    preferred: false
+    category: ide
+    description: "Google's AI development environment"
+
   trae:
     name: "Trae"
     preferred: false

package/tools/schema/agent.js

@@ -2,8 +2,41 @@
 const assert = require('node:assert');
 const { z } = require('zod');
 
-const COMMAND_TARGET_KEYS = ['workflow', 'validate-workflow', 'exec', 'action', 'tmpl', 'data', 'run-workflow'];
+const COMMAND_TARGET_KEYS = ['workflow', 'validate-workflow', 'exec', 'action', 'tmpl', 'data'];
 const TRIGGER_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const COMPOUND_TRIGGER_PATTERN = /^([A-Z]{1,3}) or fuzzy match on ([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+
+/**
+ * Derive the expected shortcut from a kebab-case trigger.
+ * - Single word: first letter (e.g., "help" → "H")
+ * - Multi-word: first letter of first two words (e.g., "tech-spec" → "TS")
+ * @param {string} kebabTrigger The kebab-case trigger name.
+ * @returns {string} The expected uppercase shortcut.
+ */
+function deriveShortcutFromKebab(kebabTrigger) {
+  const words = kebabTrigger.split('-');
+  if (words.length === 1) {
+    return words[0][0].toUpperCase();
+  }
+  return (words[0][0] + words[1][0]).toUpperCase();
+}
+
+/**
+ * Parse and validate a compound trigger string.
+ * Format: "<SHORTCUT> or fuzzy match on <kebab-case>"
+ * @param {string} triggerValue The trigger string to parse.
+ * @returns {{ valid: boolean, shortcut?: string, kebabTrigger?: string, error?: string }}
+ */
+function parseCompoundTrigger(triggerValue) {
+  const match = COMPOUND_TRIGGER_PATTERN.exec(triggerValue);
+  if (!match) {
+    return { valid: false, error: 'invalid compound trigger format' };
+  }
+
+  const [, shortcut, kebabTrigger] = match;
+
+  return { valid: true, shortcut, kebabTrigger };
+}
 
 // Public API ---------------------------------------------------------------
 
@@ -49,30 +82,119 @@ function agentSchema(options = {}) {
 
         let index = 0;
         for (const item of value.agent.menu) {
-          const triggerValue = item.trigger;
+          // Handle legacy format with trigger field
+          if (item.trigger) {
+            const triggerValue = item.trigger;
+            let canonicalTrigger = triggerValue;
 
-          if (!TRIGGER_PATTERN.test(triggerValue)) {
-            ctx.addIssue({
-              code: 'custom',
-              path: ['agent', 'menu', index, 'trigger'],
-              message: 'agent.menu[].trigger must be kebab-case (lowercase words separated by hyphen)',
-            });
-            return;
+            // Check if it's a compound trigger (contains " or ")
+            if (triggerValue.includes(' or ')) {
+              const result = parseCompoundTrigger(triggerValue);
+              if (!result.valid) {
+                ctx.addIssue({
+                  code: 'custom',
+                  path: ['agent', 'menu', index, 'trigger'],
+                  message: `agent.menu[].trigger compound format error: ${result.error}`,
+                });
+                return;
+              }
+
+              // Validate that shortcut matches description brackets
+              const descriptionMatch = item.description?.match(/^\[([A-Z]{1,3})\]/);
+              if (!descriptionMatch) {
+                ctx.addIssue({
+                  code: 'custom',
+                  path: ['agent', 'menu', index, 'description'],
+                  message: `agent.menu[].description must start with [SHORTCUT] where SHORTCUT matches the trigger shortcut "${result.shortcut}"`,
+                });
+                return;
+              }
+
+              const descriptionShortcut = descriptionMatch[1];
+              if (descriptionShortcut !== result.shortcut) {
+                ctx.addIssue({
+                  code: 'custom',
+                  path: ['agent', 'menu', index, 'description'],
+                  message: `agent.menu[].description shortcut "[${descriptionShortcut}]" must match trigger shortcut "${result.shortcut}"`,
+                });
+                return;
+              }
+
+              canonicalTrigger = result.kebabTrigger;
+            } else if (!TRIGGER_PATTERN.test(triggerValue)) {
+              ctx.addIssue({
+                code: 'custom',
+                path: ['agent', 'menu', index, 'trigger'],
+                message: 'agent.menu[].trigger must be kebab-case (lowercase words separated by hyphen)',
+              });
+              return;
+            }
+
+            if (seenTriggers.has(canonicalTrigger)) {
+              ctx.addIssue({
+                code: 'custom',
+                path: ['agent', 'menu', index, 'trigger'],
+                message: `agent.menu[].trigger duplicates "${canonicalTrigger}" within the same agent`,
+              });
+              return;
+            }
+
+            seenTriggers.add(canonicalTrigger);
           }
+          // Handle multi format with triggers array (new format)
+          else if (item.triggers && Array.isArray(item.triggers)) {
+            for (const [triggerIndex, triggerItem] of item.triggers.entries()) {
+              let triggerName = null;
 
-          if (seenTriggers.has(triggerValue)) {
-            ctx.addIssue({
-              code: 'custom',
-              path: ['agent', 'menu', index, 'trigger'],
-              message: `agent.menu[].trigger duplicates "${triggerValue}" within the same agent`,
-            });
-            return;
+              // Extract trigger name from all three formats
+              if (triggerItem.trigger) {
+                // Format 1: Simple flat format with trigger field
+                triggerName = triggerItem.trigger;
+              } else {
+                // Format 2a or 2b: Object-key format
+                const keys = Object.keys(triggerItem);
+                if (keys.length === 1 && keys[0] !== 'trigger') {
+                  triggerName = keys[0];
+                }
+              }
+
+              if (triggerName) {
+                if (!TRIGGER_PATTERN.test(triggerName)) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    path: ['agent', 'menu', index, 'triggers', triggerIndex],
+                    message: `agent.menu[].triggers[] must be kebab-case (lowercase words separated by hyphen) - got "${triggerName}"`,
+                  });
+                  return;
+                }
+
+                if (seenTriggers.has(triggerName)) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    path: ['agent', 'menu', index, 'triggers', triggerIndex],
+                    message: `agent.menu[].triggers[] duplicates "${triggerName}" within the same agent`,
+                  });
+                  return;
+                }
+
+                seenTriggers.add(triggerName);
+              }
+            }
           }
 
-          seenTriggers.add(triggerValue);
           index += 1;
         }
       })
+      // Refinement: suggest conversational_knowledge when discussion is true
+      .superRefine((value, ctx) => {
+        if (value.agent.discussion === true && !value.agent.conversational_knowledge) {
+          ctx.addIssue({
+            code: 'custom',
+            path: ['agent', 'conversational_knowledge'],
+            message: 'It is recommended to include conversational_knowledge when discussion is true',
+          });
+        }
+      })
   );
 }
 
@@ -88,14 +210,16 @@ function buildAgentSchema(expectedModule) {
       critical_actions: z.array(createNonEmptyString('agent.critical_actions[]')).optional(),
       menu: z.array(buildMenuItemSchema()).min(1, { message: 'agent.menu must include at least one entry' }),
       prompts: z.array(buildPromptSchema()).optional(),
-      webskip: z.boolean().optional(),
+      discussion: z.boolean().optional(),
+      conversational_knowledge: z.array(z.object({}).passthrough()).min(1).optional(),
     })
     .strict();
 }
 
 /**
- * Validate metadata shape and cross-check module expectation against caller input.
+ * Validate metadata shape.
  * @param {string|null} expectedModule Trimmed module slug or null when core agent metadata is expected.
+ * Note: Module field is optional and can be any value - no validation against path.
  */
 function buildMetadataSchema(expectedModule) {
   const schemaShape = {
@@ -104,37 +228,11 @@ function buildMetadataSchema(expectedModule) {
     title: createNonEmptyString('agent.metadata.title'),
     icon: createNonEmptyString('agent.metadata.icon'),
     module: createNonEmptyString('agent.metadata.module').optional(),
+    capabilities: createNonEmptyString('agent.metadata.capabilities').optional(),
+    hasSidecar: z.boolean(),
   };
 
-  return (
-    z
-      .object(schemaShape)
-      .strict()
-      // Refinement: guard presence and correctness of metadata.module.
-      .superRefine((value, ctx) => {
-        const moduleValue = typeof value.module === 'string' ? value.module.trim() : null;
-
-        if (expectedModule && !moduleValue) {
-          ctx.addIssue({
-            code: 'custom',
-            path: ['module'],
-            message: 'module-scoped agents must declare agent.metadata.module',
-          });
-        } else if (!expectedModule && moduleValue) {
-          ctx.addIssue({
-            code: 'custom',
-            path: ['module'],
-            message: 'core agents must not include agent.metadata.module',
-          });
-        } else if (expectedModule && moduleValue !== expectedModule) {
-          ctx.addIssue({
-            code: 'custom',
-            path: ['module'],
-            message: `agent.metadata.module must equal "${expectedModule}"`,
-          });
-        }
-      })
-  );
+  return z.object(schemaShape).strict();
 }
 
 function buildPersonaSchema() {
@@ -167,9 +265,11 @@ function buildPromptSchema() {
 
 /**
  * Schema for individual menu entries ensuring they are actionable.
+ * Supports both legacy format and new multi format.
  */
 function buildMenuItemSchema() {
-  return z
+  // Legacy menu item format
+  const legacyMenuItemSchema = z
     .object({
       trigger: createNonEmptyString('agent.menu[].trigger'),
       description: createNonEmptyString('agent.menu[].description'),
@@ -179,10 +279,12 @@ function buildMenuItemSchema() {
       exec: createNonEmptyString('agent.menu[].exec').optional(),
       action: createNonEmptyString('agent.menu[].action').optional(),
       tmpl: createNonEmptyString('agent.menu[].tmpl').optional(),
-      data: createNonEmptyString('agent.menu[].data').optional(),
-      'run-workflow': createNonEmptyString('agent.menu[].run-workflow').optional(),
+      data: z.string().optional(),
       checklist: createNonEmptyString('agent.menu[].checklist').optional(),
       document: createNonEmptyString('agent.menu[].document').optional(),
+      'ide-only': z.boolean().optional(),
+      'web-only': z.boolean().optional(),
+      discussion: z.boolean().optional(),
     })
     .strict()
     .superRefine((value, ctx) => {
@@ -198,10 +300,161 @@ function buildMenuItemSchema() {
         });
       }
     });
+
+  // Multi menu item format
+  const multiMenuItemSchema = z
+    .object({
+      multi: createNonEmptyString('agent.menu[].multi'),
+      triggers: z
+        .array(
+          z.union([
+            // Format 1: Simple flat format (has trigger field)
+            z
+              .object({
+                trigger: z.string(),
+                input: createNonEmptyString('agent.menu[].triggers[].input'),
+                route: createNonEmptyString('agent.menu[].triggers[].route').optional(),
+                action: createNonEmptyString('agent.menu[].triggers[].action').optional(),
+                data: z.string().optional(),
+                type: z.enum(['exec', 'action', 'workflow']).optional(),
+              })
+              .strict()
+              .refine((data) => data.trigger, { message: 'Must have trigger field' })
+              .superRefine((value, ctx) => {
+                // Must have either route or action (or both)
+                if (!value.route && !value.action) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    message: 'agent.menu[].triggers[] must have either route or action (or both)',
+                  });
+                }
+              }),
+            // Format 2a: Object with array format (like bmad-builder.agent.yaml)
+            z
+              .object({})
+              .passthrough()
+              .refine(
+                (value) => {
+                  const keys = Object.keys(value);
+                  if (keys.length !== 1) return false;
+                  const triggerItems = value[keys[0]];
+                  return Array.isArray(triggerItems);
+                },
+                { message: 'Must be object with single key pointing to array' },
+              )
+              .superRefine((value, ctx) => {
+                const triggerName = Object.keys(value)[0];
+                const triggerItems = value[triggerName];
+
+                if (!Array.isArray(triggerItems)) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    message: `Trigger "${triggerName}" must be an array of items`,
+                  });
+                  return;
+                }
+
+                // Check required fields in the array
+                const hasInput = triggerItems.some((item) => 'input' in item);
+                const hasRouteOrAction = triggerItems.some((item) => 'route' in item || 'action' in item);
+
+                if (!hasInput) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    message: `Trigger "${triggerName}" must have an input field`,
+                  });
+                }
+
+                if (!hasRouteOrAction) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    message: `Trigger "${triggerName}" must have a route or action field`,
+                  });
+                }
+              }),
+            // Format 2b: Object with direct fields (like analyst.agent.yaml)
+            z
+              .object({})
+              .passthrough()
+              .refine(
+                (value) => {
+                  const keys = Object.keys(value);
+                  if (keys.length !== 1) return false;
+                  const triggerFields = value[keys[0]];
+                  return !Array.isArray(triggerFields) && typeof triggerFields === 'object';
+                },
+                { message: 'Must be object with single key pointing to object' },
+              )
+              .superRefine((value, ctx) => {
+                const triggerName = Object.keys(value)[0];
+                const triggerFields = value[triggerName];
+
+                // Check required fields
+                if (!triggerFields.input || typeof triggerFields.input !== 'string') {
+                  ctx.addIssue({
+                    code: 'custom',
+                    message: `Trigger "${triggerName}" must have an input field`,
+                  });
+                }
+
+                if (!triggerFields.route && !triggerFields.action) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    message: `Trigger "${triggerName}" must have a route or action field`,
+                  });
+                }
+              }),
+          ]),
+        )
+        .min(1, { message: 'agent.menu[].triggers must have at least one trigger' }),
+      discussion: z.boolean().optional(),
+    })
+    .strict()
+    .superRefine((value, ctx) => {
+      // Check for duplicate trigger names
+      const seenTriggers = new Set();
+      for (const [index, triggerItem] of value.triggers.entries()) {
+        let triggerName = null;
+
+        // Extract trigger name from either format
+        if (triggerItem.trigger) {
+          // Format 1
+          triggerName = triggerItem.trigger;
+        } else {
+          // Format 2
+          const keys = Object.keys(triggerItem);
+          if (keys.length === 1) {
+            triggerName = keys[0];
+          }
+        }
+
+        if (triggerName) {
+          if (seenTriggers.has(triggerName)) {
+            ctx.addIssue({
+              code: 'custom',
+              path: ['agent', 'menu', 'triggers', index],
+              message: `Trigger name "${triggerName}" is duplicated`,
+            });
+          }
+          seenTriggers.add(triggerName);
+
+          // Validate trigger name format
+          if (!TRIGGER_PATTERN.test(triggerName)) {
+            ctx.addIssue({
+              code: 'custom',
+              path: ['agent', 'menu', 'triggers', index],
+              message: `Trigger name "${triggerName}" must be kebab-case (lowercase words separated by hyphen)`,
+            });
+          }
+        }
+      }
+    });
+
+  return z.union([legacyMenuItemSchema, multiMenuItemSchema]);
 }
 
 /**
- * Derive the expected module slug from a file path residing under src/modules/<module>/agents/.
+ * Derive the expected module slug from a file path residing under src/<module>/agents/.
  * @param {string} filePath Absolute or relative agent path.
  * @returns {string|null} Module slug if identifiable, otherwise null.
  */
@@ -210,7 +463,7 @@ function deriveModuleFromPath(filePath) {
   assert(typeof filePath === 'string', 'validateAgentFile expects filePath to be a string');
   assert(filePath.startsWith('src/'), 'validateAgentFile expects filePath to start with "src/"');
 
-  const marker = 'src/modules/';
+  const marker = 'src/';
   if (!filePath.startsWith(marker)) {
     return null;
   }

package/tools/validate-agent-schema.js

@@ -12,7 +12,7 @@
  */
 
 const { glob } = require('glob');
-const yaml = require('js-yaml');
+const yaml = require('yaml');
 const fs = require('node:fs');
 const path = require('node:path');
 const { validateAgentFile } = require('./schema/agent.js');
@@ -28,7 +28,7 @@ async function main(customProjectRoot) {
   const project_root = customProjectRoot || path.join(__dirname, '..');
 
   // Find all agent files
-  const agentFiles = await glob('src/{core,modules/*}/agents/*.agent.yaml', {
+  const agentFiles = await glob('src/{core,bmm}/agents/**/*.agent.yaml', {
     cwd: project_root,
     absolute: true,
   });
@@ -49,7 +49,7 @@ async function main(customProjectRoot) {
 
     try {
       const fileContent = fs.readFileSync(filePath, 'utf8');
-      const agentData = yaml.load(fileContent);
+      const agentData = yaml.parse(fileContent);
 
       // Convert absolute path to relative src/ path for module detection
       const srcRelativePath = relativePath.startsWith('src/') ? relativePath : path.relative(project_root, filePath).replaceAll('\\', '/');