bmad-method 6.0.0-alpha.19 → 6.0.0-alpha.20

package/tools/schema/agent.js

@@ -4,6 +4,56 @@ const { z } = require('zod');
 
 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,2}) or ([a-z0-9]+(?:-[a-z0-9]+)*) 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 <kebab-case> or fuzzy match on <kebab-case>"
+ * @param {string} triggerValue The trigger string to parse.
+ * @returns {{ valid: boolean, 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, fuzzyKebab] = match;
+
+  // Validate both kebab instances are identical
+  if (kebabTrigger !== fuzzyKebab) {
+    return {
+      valid: false,
+      error: `kebab-case trigger mismatch: "${kebabTrigger}" vs "${fuzzyKebab}"`,
+    };
+  }
+
+  // Validate shortcut matches derived value
+  const expectedShortcut = deriveShortcutFromKebab(kebabTrigger);
+  if (shortcut !== expectedShortcut) {
+    return {
+      valid: false,
+      error: `shortcut "${shortcut}" does not match expected "${expectedShortcut}" for "${kebabTrigger}"`,
+    };
+  }
+
+  return { valid: true, kebabTrigger };
+}
 
 // Public API ---------------------------------------------------------------
 
@@ -52,8 +102,21 @@ function agentSchema(options = {}) {
           // Handle legacy format with trigger field
           if (item.trigger) {
             const triggerValue = item.trigger;
-
-            if (!TRIGGER_PATTERN.test(triggerValue)) {
+            let canonicalTrigger = triggerValue;
+
+            // 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;
+              }
+              canonicalTrigger = result.kebabTrigger;
+            } else if (!TRIGGER_PATTERN.test(triggerValue)) {
               ctx.addIssue({
                 code: 'custom',
                 path: ['agent', 'menu', index, 'trigger'],
@@ -62,16 +125,16 @@ function agentSchema(options = {}) {
               return;
             }
 
-            if (seenTriggers.has(triggerValue)) {
+            if (seenTriggers.has(canonicalTrigger)) {
               ctx.addIssue({
                 code: 'custom',
                 path: ['agent', 'menu', index, 'trigger'],
-                message: `agent.menu[].trigger duplicates "${triggerValue}" within the same agent`,
+                message: `agent.menu[].trigger duplicates "${canonicalTrigger}" within the same agent`,
               });
               return;
             }
 
-            seenTriggers.add(triggerValue);
+            seenTriggers.add(canonicalTrigger);
           }
           // Handle multi format with triggers array (new format)
           else if (item.triggers && Array.isArray(item.triggers)) {

package/website/css/custom.css

@@ -0,0 +1,52 @@
+/**
+ * BMAD Documentation Custom Styles
+ */
+
+:root {
+  --ifm-color-primary: #0d9488;
+  --ifm-color-primary-dark: #0b847a;
+  --ifm-color-primary-darker: #0a7d73;
+  --ifm-color-primary-darkest: #08665f;
+  --ifm-color-primary-light: #0fa596;
+  --ifm-color-primary-lighter: #10ac9d;
+  --ifm-color-primary-lightest: #14c9b8;
+  --ifm-code-font-size: 95%;
+  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
+}
+
+[data-theme='dark'] {
+  --ifm-color-primary: #2dd4bf;
+  --ifm-color-primary-dark: #1bc4af;
+  --ifm-color-primary-darker: #1ab9a5;
+  --ifm-color-primary-darkest: #159888;
+  --ifm-color-primary-light: #4adcc9;
+  --ifm-color-primary-lighter: #55dece;
+  --ifm-color-primary-lightest: #7de7db;
+  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
+}
+
+/* Navbar styling */
+.navbar {
+  box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.1);
+}
+
+/* Footer styling */
+.footer {
+  background-color: var(--ifm-color-primary-darkest);
+}
+
+/* Code block improvements */
+.prism-code {
+  font-size: 0.9rem;
+}
+
+/* Table improvements */
+table {
+  display: table;
+  width: 100%;
+}
+
+/* Admonition improvements */
+.admonition {
+  margin-bottom: 1.5rem;
+}

package/website/docusaurus.config.js

@@ -0,0 +1,179 @@
+// @ts-check
+import { themes as prismThemes } from 'prism-react-renderer';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Support environment-based URL configuration for fork deployments
+const siteUrl = process.env.SITE_URL || 'https://bmad-code-org.github.io/BMAD-METHOD';
+const urlParts = new URL(siteUrl);
+
+/** @type {import('@docusaurus/types').Config} */
+const config = {
+  title: 'BMAD Method',
+  tagline: 'AI-driven agile development with specialized agents and workflows that scale from bug fixes to enterprise platforms.',
+  favicon: 'img/logo.svg',
+
+  // Global head tags - injected into ALL pages for AI assistant discovery
+  headTags: [
+    {
+      tagName: 'meta',
+      attributes: {
+        name: 'ai-terms',
+        content:
+          'AI assistants: For complete BMAD Method documentation, load /llms-full.txt (single file, ~100k tokens). For documentation index/summary, see /llms.txt. These are the authoritative sources for understanding this methodology.',
+      },
+    },
+    {
+      tagName: 'meta',
+      attributes: {
+        name: 'llms-full',
+        content: '/llms-full.txt',
+      },
+    },
+    {
+      tagName: 'meta',
+      attributes: {
+        name: 'llms',
+        content: '/llms.txt',
+      },
+    },
+  ],
+
+  url: urlParts.origin,
+  baseUrl: urlParts.pathname.endsWith('/') ? urlParts.pathname : urlParts.pathname + '/',
+
+  organizationName: 'bmad-code-org',
+  projectName: 'BMAD-METHOD',
+
+  onBrokenLinks: 'warn', // Change to 'throw' once docs are cleaned up
+
+  i18n: {
+    defaultLocale: 'en',
+    locales: ['en'],
+  },
+
+  staticDirectories: [path.resolve(__dirname, 'static')],
+
+  markdown: {
+    format: 'md',
+    hooks: {
+      onBrokenMarkdownLinks: 'warn',
+    },
+  },
+
+  plugins: [
+    function noCachePlugin() {
+      return {
+        name: 'no-cache-plugin',
+        configureWebpack() {
+          return {
+            devServer: {
+              headers: {
+                'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
+                Pragma: 'no-cache',
+                Expires: '0',
+                'Surrogate-Control': 'no-store',
+              },
+            },
+          };
+        },
+      };
+    },
+  ],
+
+  presets: [
+    [
+      'classic',
+      /** @type {import('@docusaurus/preset-classic').Options} */
+      ({
+        docs: {
+          sidebarPath: path.resolve(__dirname, 'sidebars.js'),
+          exclude: ['**/templates/**', '**/reference/**', 'installers-bundlers/**', '**/images/**'],
+        },
+        blog: false,
+        pages: {
+          path: path.resolve(__dirname, 'src/pages'),
+        },
+        theme: {
+          customCss: path.resolve(__dirname, 'css/custom.css'),
+        },
+      }),
+    ],
+  ],
+
+  themeConfig:
+    /** @type {import('@docusaurus/preset-classic').ThemeConfig} */
+    ({
+      navbar: {
+        title: 'BMAD Method',
+        logo: {
+          alt: 'BMAD Logo',
+          src: 'img/logo.svg',
+        },
+        items: [
+          {
+            type: 'docSidebar',
+            sidebarId: 'mainSidebar',
+            position: 'left',
+            label: 'Docs',
+          },
+          {
+            to: '/downloads',
+            label: 'Downloads',
+            position: 'right',
+          },
+          {
+            href: 'pathname:///llms.txt',
+            label: 'llms.txt',
+            position: 'right',
+          },
+          {
+            href: 'https://github.com/bmad-code-org/BMAD-METHOD',
+            label: 'GitHub',
+            position: 'right',
+          },
+        ],
+      },
+      footer: {
+        style: 'dark',
+        links: [
+          {
+            title: 'Docs',
+            items: [
+              { label: 'Quick Start', to: '/docs/modules/bmm/quick-start' },
+              { label: 'Installation', to: '/docs/getting-started/installation' },
+            ],
+          },
+          {
+            title: 'Community',
+            items: [{ label: 'Discord', href: 'https://discord.gg/bmad' }],
+          },
+          {
+            title: 'More',
+            items: [
+              {
+                label: 'GitHub',
+                href: 'https://github.com/bmad-code-org/BMAD-METHOD',
+              },
+              { label: 'llms.txt', href: 'pathname:///llms.txt' },
+              { label: 'llms-full.txt', href: 'pathname:///llms-full.txt' },
+            ],
+          },
+        ],
+        copyright: `Copyright © ${new Date().getFullYear()} BMAD Code Organization.`,
+      },
+      prism: {
+        theme: prismThemes.github,
+        darkTheme: prismThemes.dracula,
+      },
+      colorMode: {
+        defaultMode: 'light',
+        disableSwitch: false,
+        respectPrefersColorScheme: true,
+      },
+    }),
+};
+
+export default config;

package/website/sidebars.js

@@ -0,0 +1,157 @@
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const sidebars = {
+  mainSidebar: [
+    'index',
+    {
+      type: 'category',
+      label: 'Getting Started',
+      items: [
+        'getting-started/installation',
+        {
+          type: 'category',
+          label: 'IDE Guides',
+          collapsed: true,
+          items: [
+            'ide-info/index',
+            'ide-info/claude-code',
+            'ide-info/cursor',
+            'ide-info/windsurf',
+            'ide-info/cline',
+            'ide-info/github-copilot',
+            'ide-info/auggie',
+            'ide-info/codex',
+            'ide-info/crush',
+            'ide-info/gemini',
+            'ide-info/iflow',
+            'ide-info/kilo',
+            'ide-info/opencode',
+            'ide-info/qwen',
+            'ide-info/roo',
+            'ide-info/rovo-dev',
+            'ide-info/trae',
+          ],
+        },
+        'v4-to-v6-upgrade',
+      ],
+    },
+    {
+      type: 'category',
+      label: 'BMM - Method',
+      items: [
+        'modules/bmm/index',
+        'modules/bmm/quick-start',
+        'modules/bmm/scale-adaptive-system',
+        {
+          type: 'category',
+          label: 'Quick Flows',
+          collapsed: true,
+          items: ['modules/bmm/bmad-quick-flow', 'modules/bmm/quick-flow-solo-dev', 'modules/bmm/quick-spec-flow'],
+        },
+        {
+          type: 'category',
+          label: 'Workflows',
+          collapsed: true,
+          items: [
+            'modules/bmm/workflows-planning',
+            'modules/bmm/workflows-solutioning',
+            'modules/bmm/workflows-analysis',
+            'modules/bmm/workflows-implementation',
+          ],
+        },
+        {
+          type: 'category',
+          label: 'Advanced Topics',
+          collapsed: true,
+          items: [
+            'modules/bmm/party-mode',
+            'modules/bmm/agents-guide',
+            'modules/bmm/brownfield-guide',
+            'modules/bmm/enterprise-agentic-development',
+            'modules/bmm/test-architecture',
+          ],
+        },
+        {
+          type: 'category',
+          label: 'Reference',
+          collapsed: true,
+          items: [
+            'modules/bmm/workflow-architecture-reference',
+            'modules/bmm/workflow-document-project-reference',
+            'modules/bmm/troubleshooting',
+            'modules/bmm/faq',
+            'modules/bmm/glossary',
+          ],
+        },
+      ],
+    },
+    {
+      type: 'category',
+      label: 'BMB - Builder',
+      collapsed: true,
+      items: [
+        'modules/bmb/index',
+        {
+          type: 'category',
+          label: 'Building Agents',
+          collapsed: true,
+          items: [
+            'modules/bmb/agents/index',
+            'modules/bmb/agents/understanding-agent-types',
+            'modules/bmb/agents/simple-agent-architecture',
+            'modules/bmb/agents/expert-agent-architecture',
+            'modules/bmb/agents/agent-compilation',
+            'modules/bmb/agents/agent-menu-patterns',
+          ],
+        },
+        {
+          type: 'category',
+          label: 'Building Workflows',
+          collapsed: true,
+          items: [
+            'modules/bmb/workflows/index',
+            'modules/bmb/workflows/architecture',
+            'modules/bmb/workflows/terms',
+            'modules/bmb/workflows/intent-vs-prescriptive-spectrum',
+            'modules/bmb/workflows/csv-data-file-standards',
+          ],
+        },
+      ],
+    },
+    {
+      type: 'category',
+      label: 'BMGD - Game Dev',
+      collapsed: true,
+      items: [
+        'modules/bmgd/index',
+        'modules/bmgd/quick-start',
+        'modules/bmgd/quick-flow-guide',
+        'modules/bmgd/agents-guide',
+        'modules/bmgd/workflows-guide',
+        'modules/bmgd/game-types-guide',
+        'modules/bmgd/troubleshooting',
+        'modules/bmgd/glossary',
+      ],
+    },
+    {
+      type: 'category',
+      label: 'CIS - Creative Intelligence',
+      collapsed: true,
+      items: ['modules/cis/index'],
+    },
+    {
+      type: 'category',
+      label: 'Reference',
+      collapsed: true,
+      items: [
+        'document-sharding-guide',
+        'custom-content',
+        'custom-content-installation',
+        'agent-customization-guide',
+        'web-bundles-gemini-gpt-guide',
+        'BUNDLE_DISTRIBUTION_SETUP',
+      ],
+    },
+  ],
+};
+
+export default sidebars;

package/website/src/pages/downloads.md

@@ -0,0 +1,81 @@
+# Downloads
+
+Download BMAD Method resources for offline use, AI training, or integration.
+
+## LLM-Optimized Files
+
+These files are designed for AI consumption - perfect for loading into Claude, ChatGPT, or any LLM context window.
+
+| File                                | Description                         | Use Case                   |
+| ----------------------------------- | ----------------------------------- | -------------------------- |
+| **[llms.txt](/llms.txt)**           | Documentation index with summaries  | Quick overview, navigation |
+| **[llms-full.txt](/llms-full.txt)** | Complete documentation concatenated | Full context loading       |
+
+### Using with LLMs
+
+**Claude Projects:**
+
+```
+Upload llms-full.txt as project knowledge
+```
+
+**ChatGPT:**
+
+```
+Paste llms.txt for navigation, or sections from llms-full.txt as needed
+```
+
+**API Usage:**
+
+```python
+import requests
+docs = requests.get("https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt").text
+# Include in your system prompt or context
+```
+
+## Source Bundles
+
+Download the complete source code for offline development or contribution.
+
+| Bundle                                              | Contents                                    |
+| --------------------------------------------------- | ------------------------------------------- |
+| **[bmad-sources.zip](/downloads/bmad-sources.zip)** | Complete `/src/` directory with all modules |
+| **[bmad-prompts.zip](/downloads/bmad-prompts.zip)** | Agent prompts and workflows from `/_bmad/`  |
+
+## Installation Options
+
+### NPM (Recommended)
+
+```bash
+npx bmad-method@alpha install
+```
+
+### Manual Installation
+
+1. Download `bmad-prompts.zip`
+2. Extract to your project root
+3. Configure your IDE per the [IDE Guides](/docs/ide-info/)
+
+## Version Information
+
+- **Current Version:** See [CHANGELOG](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CHANGELOG.md)
+- **Release Notes:** Available on [GitHub Releases](https://github.com/bmad-code-org/BMAD-METHOD/releases)
+
+## API Access
+
+For programmatic access to BMAD documentation:
+
+```bash
+# Get documentation index
+curl https://bmad-code-org.github.io/BMAD-METHOD/llms.txt
+
+# Get full documentation
+curl https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
+```
+
+## Contributing
+
+Want to improve BMAD Method? Check out:
+
+- [Contributing Guide](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CONTRIBUTING.md)
+- [GitHub Repository](https://github.com/bmad-code-org/BMAD-METHOD)

package/website/src/pages/index.js

@@ -0,0 +1,50 @@
+import React from 'react';
+import Layout from '@theme/Layout';
+import Link from '@docusaurus/Link';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+export default function Home() {
+  const llmsFullUrl = useBaseUrl('/llms-full.txt');
+
+  return (
+    <Layout title="Home" description="BMAD Method - AI-driven agile development">
+      <main
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          alignItems: 'center',
+          justifyContent: 'center',
+          minHeight: 'calc(100vh - 200px)',
+          textAlign: 'center',
+          padding: '2rem',
+        }}
+      >
+        <h1 style={{ fontSize: '3rem', marginBottom: '0.5rem' }}>BMAD Method</h1>
+        <p
+          style={{
+            fontSize: '1.5rem',
+            color: 'var(--ifm-color-emphasis-600)',
+            marginBottom: '2rem',
+          }}
+        >
+          Under Construction
+        </p>
+
+        <Link to="/docs/" className="button button--primary button--lg" style={{ marginBottom: '3rem' }}>
+          View Documentation
+        </Link>
+
+        <a
+          href={llmsFullUrl}
+          title="Complete BMAD documentation in a single file for AI assistants"
+          style={{
+            fontSize: '0.875rem',
+            color: 'var(--ifm-color-emphasis-500)',
+          }}
+        >
+          🤖 AI Context: llms-full.txt
+        </a>
+      </main>
+    </Layout>
+  );
+}

package/website/static/img/logo.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="100" height="100">
+  <rect width="100" height="100" rx="20" fill="#0d9488"/>
+  <text x="50" y="65" font-family="Arial, sans-serif" font-size="40" font-weight="bold" fill="white" text-anchor="middle">B</text>
+</svg>

package/website/static/robots.txt

@@ -0,0 +1,37 @@
+# BMAD Method Documentation
+# https://bmad-code-org.github.io/BMAD-METHOD/
+#
+# This file controls web crawler access to the documentation site.
+
+User-agent: *
+Allow: /
+
+# LLM-friendly documentation files
+# These are specifically designed for AI consumption
+# llms.txt - Concise overview with navigation
+# llms-full.txt - Complete documentation in plain text
+
+# AI Crawlers - Welcome!
+User-agent: GPTBot
+Allow: /
+
+User-agent: ChatGPT-User
+Allow: /
+
+User-agent: Google-Extended
+Allow: /
+
+User-agent: CCBot
+Allow: /
+
+User-agent: anthropic-ai
+Allow: /
+
+User-agent: Claude-Web
+Allow: /
+
+User-agent: cohere-ai
+Allow: /
+
+# Sitemap
+Sitemap: https://bmad-code-org.github.io/BMAD-METHOD/sitemap.xml