bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.2

package/tools/cli/installers/lib/ide/workflow-command-generator.js

@@ -17,32 +17,26 @@ class WorkflowCommandGenerator {
    * @param {string} bmadDir - BMAD installation directory
    */
   async generateWorkflowCommands(projectDir, bmadDir) {
-    const manifestPath = path.join(bmadDir, '_cfg', 'workflow-manifest.csv');
+    const workflows = await this.loadWorkflowManifest(bmadDir);
 
-    if (!(await fs.pathExists(manifestPath))) {
+    if (!workflows) {
       console.log(chalk.yellow('Workflow manifest not found. Skipping command generation.'));
       return { generated: 0 };
     }
 
-    // Read and parse the CSV manifest
-    const csvContent = await fs.readFile(manifestPath, 'utf8');
-    const workflows = csv.parse(csvContent, {
-      columns: true,
-      skip_empty_lines: true,
-    });
+    // Filter to only standalone workflows
+    const standaloneWorkflows = workflows.filter((w) => w.standalone === 'true' || w.standalone === true);
 
     // Base commands directory
     const baseCommandsDir = path.join(projectDir, '.claude', 'commands', 'bmad');
 
     let generatedCount = 0;
 
-    // Generate a command file for each workflow, organized by module
-    for (const workflow of workflows) {
-      // Create module directory structure: commands/bmad/{module}/workflows/
+    // Generate a command file for each standalone workflow, organized by module
+    for (const workflow of standaloneWorkflows) {
       const moduleWorkflowsDir = path.join(baseCommandsDir, workflow.module, 'workflows');
       await fs.ensureDir(moduleWorkflowsDir);
 
-      // Use just the workflow name as filename (no prefix)
       const commandContent = await this.generateCommandContent(workflow, bmadDir);
       const commandPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
 
@@ -51,11 +45,55 @@ class WorkflowCommandGenerator {
     }
 
     // Also create a workflow launcher README in each module
-    await this.createModuleWorkflowLaunchers(baseCommandsDir, workflows, bmadDir);
+    const groupedWorkflows = this.groupWorkflowsByModule(standaloneWorkflows);
+    await this.createModuleWorkflowLaunchers(baseCommandsDir, groupedWorkflows);
 
     return { generated: generatedCount };
   }
 
+  async collectWorkflowArtifacts(bmadDir) {
+    const workflows = await this.loadWorkflowManifest(bmadDir);
+
+    if (!workflows) {
+      return { artifacts: [], counts: { commands: 0, launchers: 0 } };
+    }
+
+    // Filter to only standalone workflows
+    const standaloneWorkflows = workflows.filter((w) => w.standalone === 'true' || w.standalone === true);
+
+    const artifacts = [];
+
+    for (const workflow of standaloneWorkflows) {
+      const commandContent = await this.generateCommandContent(workflow, bmadDir);
+      artifacts.push({
+        type: 'workflow-command',
+        module: workflow.module,
+        relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
+        content: commandContent,
+        sourcePath: workflow.path,
+      });
+    }
+
+    const groupedWorkflows = this.groupWorkflowsByModule(standaloneWorkflows);
+    for (const [module, launcherContent] of Object.entries(this.buildModuleWorkflowLaunchers(groupedWorkflows))) {
+      artifacts.push({
+        type: 'workflow-launcher',
+        module,
+        relativePath: path.join(module, 'workflows', 'README.md'),
+        content: launcherContent,
+        sourcePath: null,
+      });
+    }
+
+    return {
+      artifacts,
+      counts: {
+        commands: standaloneWorkflows.length,
+        launchers: Object.keys(groupedWorkflows).length,
+      },
+    };
+  }
+
   /**
    * Generate command content for a workflow
    */
@@ -94,55 +132,63 @@ class WorkflowCommandGenerator {
   /**
    * Create workflow launcher files for each module
    */
-  async createModuleWorkflowLaunchers(baseCommandsDir, workflows, bmadDir) {
-    // Group workflows by module
+  async createModuleWorkflowLaunchers(baseCommandsDir, workflowsByModule) {
+    for (const [module, moduleWorkflows] of Object.entries(workflowsByModule)) {
+      const content = this.buildLauncherContent(module, moduleWorkflows);
+      const moduleWorkflowsDir = path.join(baseCommandsDir, module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+      const launcherPath = path.join(moduleWorkflowsDir, 'README.md');
+      await fs.writeFile(launcherPath, content);
+    }
+  }
+
+  groupWorkflowsByModule(workflows) {
     const workflowsByModule = {};
+
     for (const workflow of workflows) {
       if (!workflowsByModule[workflow.module]) {
         workflowsByModule[workflow.module] = [];
       }
 
-      // Convert path for display
-      let workflowPath = workflow.path;
-      if (workflowPath.includes('/src/modules/')) {
-        const match = workflowPath.match(/\/src\/modules\/(.+)/);
-        if (match) {
-          workflowPath = `{project-root}/bmad/${match[1]}`;
-        }
-      } else if (workflowPath.includes('/src/core/')) {
-        const match = workflowPath.match(/\/src\/core\/(.+)/);
-        if (match) {
-          workflowPath = `{project-root}/bmad/core/${match[1]}`;
-        }
-      }
-
       workflowsByModule[workflow.module].push({
         ...workflow,
-        displayPath: workflowPath,
+        displayPath: this.transformWorkflowPath(workflow.path),
       });
     }
 
-    // Create a launcher file for each module
-    for (const [module, moduleWorkflows] of Object.entries(workflowsByModule)) {
-      let content = `# ${module.toUpperCase()} Workflows
+    return workflowsByModule;
+  }
+
+  buildModuleWorkflowLaunchers(groupedWorkflows) {
+    const launchers = {};
+
+    for (const [module, moduleWorkflows] of Object.entries(groupedWorkflows)) {
+      launchers[module] = this.buildLauncherContent(module, moduleWorkflows);
+    }
+
+    return launchers;
+  }
+
+  buildLauncherContent(module, moduleWorkflows) {
+    let content = `# ${module.toUpperCase()} Workflows
 
 ## Available Workflows in ${module}
 
 `;
 
-      for (const workflow of moduleWorkflows) {
-        content += `**${workflow.name}**\n`;
-        content += `- Path: \`${workflow.displayPath}\`\n`;
-        content += `- ${workflow.description}\n\n`;
-      }
+    for (const workflow of moduleWorkflows) {
+      content += `**${workflow.name}**\n`;
+      content += `- Path: \`${workflow.displayPath}\`\n`;
+      content += `- ${workflow.description}\n\n`;
+    }
 
-      content += `
+    content += `
 ## Execution
 
 When running any workflow:
-1. LOAD {project-root}/bmad/core/tasks/workflow.md
+1. LOAD {project-root}/bmad/core/tasks/workflow.xml
 2. Pass the workflow path as 'workflow-config' parameter
-3. Follow workflow.md instructions EXACTLY
+3. Follow workflow.xml instructions EXACTLY
 4. Save outputs after EACH section
 
 ## Modes
@@ -150,12 +196,39 @@ When running any workflow:
 - #yolo: Skip optional steps
 `;
 
-      // Write module-specific launcher
-      const moduleWorkflowsDir = path.join(baseCommandsDir, module, 'workflows');
-      await fs.ensureDir(moduleWorkflowsDir);
-      const launcherPath = path.join(moduleWorkflowsDir, 'README.md');
-      await fs.writeFile(launcherPath, content);
+    return content;
+  }
+
+  transformWorkflowPath(workflowPath) {
+    let transformed = workflowPath;
+
+    if (workflowPath.includes('/src/modules/')) {
+      const match = workflowPath.match(/\/src\/modules\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/bmad/${match[1]}`;
+      }
+    } else if (workflowPath.includes('/src/core/')) {
+      const match = workflowPath.match(/\/src\/core\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/bmad/core/${match[1]}`;
+      }
     }
+
+    return transformed;
+  }
+
+  async loadWorkflowManifest(bmadDir) {
+    const manifestPath = path.join(bmadDir, '_cfg', 'workflow-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
   }
 }
 

package/tools/cli/installers/lib/ide/workflow-command-template.md

@@ -1,11 +1,15 @@
+---
+description: '{{description}}'
+---
+
 # {{name}}
 
 IT IS CRITICAL THAT YOU FOLLOW THESE STEPS - while staying in character as the current agent persona you may have loaded:
 
 <steps CRITICAL="TRUE">
-1. Always LOAD the FULL {project-root}/bmad/core/tasks/workflow.md
+1. Always LOAD the FULL {project-root}/bmad/core/tasks/workflow.xml
 2. READ its entire contents - this is the CORE OS for EXECUTING the specific workflow-config {{workflow_path}}
-3. Pass the yaml path {{workflow_path}} as 'workflow-config' parameter to the workflow.md instructions
-4. Follow workflow.md instructions EXACTLY as written
+3. Pass the yaml path {{workflow_path}} as 'workflow-config' parameter to the workflow.xml instructions
+4. Follow workflow.xml instructions EXACTLY as written
 5. Save outputs after EACH section when generating any documents from templates
 </steps>

package/tools/cli/installers/lib/modules/manager.js

@@ -46,7 +46,7 @@ class ModuleManager {
       if (entry.isDirectory()) {
         const modulePath = path.join(this.modulesSourcePath, entry.name);
         // Check for new structure first
-        const installerConfigPath = path.join(modulePath, '_module-installer', 'install-menu-config.yaml');
+        const installerConfigPath = path.join(modulePath, '_module-installer', 'install-config.yaml');
         // Fallback to old structure
         const configPath = path.join(modulePath, 'config.yaml');
 
@@ -113,7 +113,7 @@ class ModuleManager {
     }
 
     // Copy module files with filtering
-    await this.copyModuleWithFiltering(sourcePath, targetPath, fileTrackingCallback);
+    await this.copyModuleWithFiltering(sourcePath, targetPath, fileTrackingCallback, options.moduleConfig);
 
     // Process agent files to inject activation block
     await this.processAgentFiles(targetPath, moduleName);
@@ -231,14 +231,26 @@ class ModuleManager {
   }
 
   /**
-   * Copy module with filtering for localskip agents
+   * Copy module with filtering for localskip agents and conditional content
    * @param {string} sourcePath - Source module path
    * @param {string} targetPath - Target module path
+   * @param {Function} fileTrackingCallback - Optional callback to track installed files
+   * @param {Object} moduleConfig - Module configuration with conditional flags
    */
-  async copyModuleWithFiltering(sourcePath, targetPath, fileTrackingCallback = null) {
+  async copyModuleWithFiltering(sourcePath, targetPath, fileTrackingCallback = null, moduleConfig = {}) {
     // Get all files in source
     const sourceFiles = await this.getFileList(sourcePath);
 
+    // Game development files to conditionally exclude
+    const gameDevFiles = [
+      'agents/game-architect.agent.yaml',
+      'agents/game-designer.agent.yaml',
+      'agents/game-dev.agent.yaml',
+      'workflows/1-analysis/brainstorm-game',
+      'workflows/1-analysis/game-brief',
+      'workflows/2-plan-workflows/gdd',
+    ];
+
     for (const file of sourceFiles) {
       // Skip sub-modules directory - these are IDE-specific and handled separately
       if (file.startsWith('sub-modules/')) {
@@ -255,6 +267,19 @@ class ModuleManager {
         continue;
       }
 
+      // Skip game development content if include_game_planning is false
+      if (moduleConfig.include_game_planning === false) {
+        const shouldSkipGameDev = gameDevFiles.some((gamePath) => {
+          // Check if file path starts with or is within any game dev directory
+          return file === gamePath || file.startsWith(gamePath + '/') || file.startsWith(gamePath + '\\');
+        });
+
+        if (shouldSkipGameDev) {
+          console.log(chalk.dim(`  Skipping game dev content: ${file}`));
+          continue;
+        }
+      }
+
       const sourceFile = path.join(sourcePath, file);
       const targetFile = path.join(targetPath, file);
 
@@ -271,9 +296,15 @@ class ModuleManager {
         }
       }
 
-      // Copy the file
-      await fs.ensureDir(path.dirname(targetFile));
-      await fs.copy(sourceFile, targetFile, { overwrite: true });
+      // Check if this is a workflow.yaml file
+      if (file.endsWith('workflow.yaml')) {
+        await fs.ensureDir(path.dirname(targetFile));
+        await this.copyWorkflowYamlStripped(sourceFile, targetFile);
+      } else {
+        // Copy the file normally
+        await fs.ensureDir(path.dirname(targetFile));
+        await fs.copy(sourceFile, targetFile, { overwrite: true });
+      }
 
       // Track the file if callback provided
       if (fileTrackingCallback) {
@@ -282,6 +313,91 @@ class ModuleManager {
     }
   }
 
+  /**
+   * Copy workflow.yaml file with web_bundle section stripped
+   * Preserves comments, formatting, and line breaks
+   * @param {string} sourceFile - Source workflow.yaml file path
+   * @param {string} targetFile - Target workflow.yaml file path
+   */
+  async copyWorkflowYamlStripped(sourceFile, targetFile) {
+    // Read the source YAML file
+    let yamlContent = await fs.readFile(sourceFile, 'utf8');
+
+    try {
+      // First check if web_bundle exists by parsing
+      const workflowConfig = yaml.load(yamlContent);
+
+      if (workflowConfig.web_bundle === undefined) {
+        // No web_bundle section, just copy as-is
+        await fs.writeFile(targetFile, yamlContent, 'utf8');
+        return;
+      }
+
+      // Remove web_bundle section using regex to preserve formatting
+      // Match the web_bundle key and all its content (including nested items)
+      // This handles both web_bundle: false and web_bundle: {...}
+
+      // Find the line that starts web_bundle
+      const lines = yamlContent.split('\n');
+      let startIdx = -1;
+      let endIdx = -1;
+      let baseIndent = 0;
+
+      // Find the start of web_bundle section
+      for (const [i, line] of lines.entries()) {
+        const match = line.match(/^(\s*)web_bundle:/);
+        if (match) {
+          startIdx = i;
+          baseIndent = match[1].length;
+          break;
+        }
+      }
+
+      if (startIdx === -1) {
+        // web_bundle not found in text (shouldn't happen), copy as-is
+        await fs.writeFile(targetFile, yamlContent, 'utf8');
+        return;
+      }
+
+      // Find the end of web_bundle section
+      // It ends when we find a line with same or less indentation that's not empty/comment
+      endIdx = startIdx;
+      for (let i = startIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Skip empty lines and comments
+        if (line.trim() === '' || line.trim().startsWith('#')) {
+          continue;
+        }
+
+        // Check indentation
+        const indent = line.match(/^(\s*)/)[1].length;
+        if (indent <= baseIndent) {
+          // Found next section at same or lower indentation
+          endIdx = i - 1;
+          break;
+        }
+      }
+
+      // If we didn't find an end, it goes to end of file
+      if (endIdx === startIdx) {
+        endIdx = lines.length - 1;
+      }
+
+      // Remove the web_bundle section (including the line before if it's just a blank line)
+      const newLines = [...lines.slice(0, startIdx), ...lines.slice(endIdx + 1)];
+
+      // Clean up any double blank lines that might result
+      const strippedYaml = newLines.join('\n').replaceAll(/\n\n\n+/g, '\n\n');
+
+      await fs.writeFile(targetFile, strippedYaml, 'utf8');
+    } catch {
+      // If anything fails, just copy the file as-is
+      console.warn(chalk.yellow(`  Warning: Could not process ${path.basename(sourceFile)}, copying as-is`));
+      await fs.copy(sourceFile, targetFile, { overwrite: true });
+    }
+  }
+
   /**
    * Process agent files to inject activation block
    * @param {string} modulePath - Path to installed module

package/tools/cli/lib/activation-builder.js

@@ -0,0 +1,168 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const { getSourcePath } = require('./project-root');
+
+/**
+ * Builds activation blocks from fragments based on agent profile
+ */
+class ActivationBuilder {
+  constructor() {
+    this.fragmentsDir = getSourcePath('utility', 'models', 'fragments');
+    this.fragmentCache = new Map();
+  }
+
+  /**
+   * Load a fragment file
+   * @param {string} fragmentName - Name of fragment file (e.g., 'activation-init.xml')
+   * @returns {string} Fragment content
+   */
+  async loadFragment(fragmentName) {
+    // Check cache first
+    if (this.fragmentCache.has(fragmentName)) {
+      return this.fragmentCache.get(fragmentName);
+    }
+
+    const fragmentPath = path.join(this.fragmentsDir, fragmentName);
+
+    if (!(await fs.pathExists(fragmentPath))) {
+      throw new Error(`Fragment not found: ${fragmentName}`);
+    }
+
+    const content = await fs.readFile(fragmentPath, 'utf8');
+    this.fragmentCache.set(fragmentName, content);
+    return content;
+  }
+
+  /**
+   * Build complete activation block based on agent profile
+   * @param {Object} profile - Agent profile from AgentAnalyzer
+   * @param {Object} metadata - Agent metadata (module, name, etc.)
+   * @param {Array} agentSpecificActions - Optional agent-specific critical actions
+   * @param {boolean} forWebBundle - Whether this is for a web bundle
+   * @returns {string} Complete activation block XML
+   */
+  async buildActivation(profile, metadata = {}, agentSpecificActions = [], forWebBundle = false) {
+    let activation = '<activation critical="MANDATORY">\n';
+
+    // 1. Build sequential steps (use web-specific steps for web bundles)
+    const steps = await this.buildSteps(metadata, agentSpecificActions, forWebBundle);
+    activation += this.indent(steps, 2) + '\n';
+
+    // 2. Build menu handlers section with dynamic handlers
+    const menuHandlers = await this.loadFragment('menu-handlers.xml');
+
+    // Build handlers (load only needed handlers)
+    const handlers = await this.buildHandlers(profile);
+
+    // Remove the extract line from the final output - it's just build metadata
+    // The extract list tells us which attributes to look for during processing
+    // but shouldn't appear in the final agent file
+    const processedHandlers = menuHandlers
+      .replace('<extract>{DYNAMIC_EXTRACT_LIST}</extract>\n', '') // Remove the entire extract line
+      .replace('{DYNAMIC_HANDLERS}', handlers);
+
+    activation += '\n' + this.indent(processedHandlers, 2) + '\n';
+
+    // 3. Include rules (skip for web bundles as they're in web-bundle-activation-steps.xml)
+    if (!forWebBundle) {
+      const rules = await this.loadFragment('activation-rules.xml');
+      activation += this.indent(rules, 2) + '\n';
+    }
+
+    activation += '</activation>';
+
+    return activation;
+  }
+
+  /**
+   * Build handlers section based on profile
+   * @param {Object} profile - Agent profile
+   * @returns {string} Handlers XML
+   */
+  async buildHandlers(profile) {
+    const handlerFragments = [];
+
+    for (const attrType of profile.usedAttributes) {
+      const fragmentName = `handler-${attrType}.xml`;
+      try {
+        const handler = await this.loadFragment(fragmentName);
+        handlerFragments.push(handler);
+      } catch {
+        console.warn(`Warning: Handler fragment not found: ${fragmentName}`);
+      }
+    }
+
+    return handlerFragments.join('\n');
+  }
+
+  /**
+   * Build sequential activation steps
+   * @param {Object} metadata - Agent metadata
+   * @param {Array} agentSpecificActions - Optional agent-specific actions
+   * @param {boolean} forWebBundle - Whether this is for a web bundle
+   * @returns {string} Steps XML
+   */
+  async buildSteps(metadata = {}, agentSpecificActions = [], forWebBundle = false) {
+    // Use web-specific fragment for web bundles, standard fragment otherwise
+    const fragmentName = forWebBundle ? 'web-bundle-activation-steps.xml' : 'activation-steps.xml';
+    const stepsTemplate = await this.loadFragment(fragmentName);
+
+    // Extract basename from agent ID (e.g., "bmad/bmm/agents/pm.md" → "pm")
+    const agentBasename = metadata.id ? metadata.id.split('/').pop().replace('.md', '') : metadata.name || 'agent';
+
+    // Build agent-specific steps
+    let agentStepsXml = '';
+    let currentStepNum = 4; // Steps 1-3 are standard
+
+    if (agentSpecificActions && agentSpecificActions.length > 0) {
+      agentStepsXml = agentSpecificActions
+        .map((action) => {
+          const step = `<step n="${currentStepNum}">${action}</step>`;
+          currentStepNum++;
+          return step;
+        })
+        .join('\n');
+    }
+
+    // Calculate final step numbers
+    const menuStep = currentStepNum;
+    const haltStep = currentStepNum + 1;
+    const inputStep = currentStepNum + 2;
+    const executeStep = currentStepNum + 3;
+
+    // Replace placeholders
+    const processed = stepsTemplate
+      .replace('{agent-file-basename}', agentBasename)
+      .replace('{{module}}', metadata.module || 'core') // Fixed to use {{module}}
+      .replace('{AGENT_SPECIFIC_STEPS}', agentStepsXml)
+      .replace('{MENU_STEP}', menuStep.toString())
+      .replace('{HALT_STEP}', haltStep.toString())
+      .replace('{INPUT_STEP}', inputStep.toString())
+      .replace('{EXECUTE_STEP}', executeStep.toString());
+
+    return processed;
+  }
+
+  /**
+   * Indent XML content
+   * @param {string} content - Content to indent
+   * @param {number} spaces - Number of spaces to indent
+   * @returns {string} Indented content
+   */
+  indent(content, spaces) {
+    const indentation = ' '.repeat(spaces);
+    return content
+      .split('\n')
+      .map((line) => (line ? indentation + line : line))
+      .join('\n');
+  }
+
+  /**
+   * Clear fragment cache (useful for testing or hot reload)
+   */
+  clearCache() {
+    this.fragmentCache.clear();
+  }
+}
+
+module.exports = { ActivationBuilder };

package/tools/cli/lib/agent-analyzer.js

@@ -0,0 +1,81 @@
+const yaml = require('js-yaml');
+const fs = require('fs-extra');
+
+/**
+ * Analyzes agent YAML files to detect which handlers are needed
+ */
+class AgentAnalyzer {
+  /**
+   * Analyze an agent YAML structure to determine which handlers it needs
+   * @param {Object} agentYaml - Parsed agent YAML object
+   * @returns {Object} Profile of needed handlers
+   */
+  analyzeAgentObject(agentYaml) {
+    const profile = {
+      usedAttributes: new Set(),
+      hasPrompts: false,
+      menuItems: [],
+    };
+
+    // Check if agent has prompts section
+    if (agentYaml.agent && agentYaml.agent.prompts) {
+      profile.hasPrompts = true;
+    }
+
+    // Analyze menu items (support both 'menu' and legacy 'commands')
+    const menuItems = agentYaml.agent?.menu || agentYaml.agent?.commands || [];
+
+    for (const item of menuItems) {
+      // Track the menu item
+      profile.menuItems.push(item);
+
+      // Check for each possible attribute
+      if (item.workflow) {
+        profile.usedAttributes.add('workflow');
+      }
+      if (item['validate-workflow']) {
+        profile.usedAttributes.add('validate-workflow');
+      }
+      if (item.exec) {
+        profile.usedAttributes.add('exec');
+      }
+      if (item.tmpl) {
+        profile.usedAttributes.add('tmpl');
+      }
+      if (item.data) {
+        profile.usedAttributes.add('data');
+      }
+      if (item.action) {
+        profile.usedAttributes.add('action');
+      }
+    }
+
+    // Convert Set to Array for easier use
+    profile.usedAttributes = [...profile.usedAttributes];
+
+    return profile;
+  }
+
+  /**
+   * Analyze an agent YAML file
+   * @param {string} filePath - Path to agent YAML file
+   * @returns {Object} Profile of needed handlers
+   */
+  async analyzeAgentFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const agentYaml = yaml.load(content);
+    return this.analyzeAgentObject(agentYaml);
+  }
+
+  /**
+   * Check if an agent needs a specific handler
+   * @param {Object} profile - Agent profile from analyze
+   * @param {string} handlerType - Handler type to check
+   * @returns {boolean} True if handler is needed
+   */
+  needsHandler(profile, handlerType) {
+    return profile.usedAttributes.includes(handlerType);
+  }
+}
+
+module.exports = { AgentAnalyzer };