bmad-method 5.1.2 → 6.0.0-alpha.0

package/src/modules/bmb/workflows/redoc/checklist.md

@@ -0,0 +1,99 @@
+# ReDoc Workflow Validation Checklist
+
+## Initialization & Setup
+
+- [ ] All BMAD convention documents loaded and understood
+- [ ] Target path validated and exists
+- [ ] Target type correctly identified (module/workflow/agent/folder)
+- [ ] Documentation execution plan created with reverse-tree order
+
+## File Analysis
+
+- [ ] All files in target scope read completely (no offset/limit usage)
+- [ ] Existing README.md files detected and last-redoc-date parsed
+- [ ] Massive folders (>10 items) identified for catalog document creation
+- [ ] Documentation depth levels calculated correctly
+
+## Leaf-Level Documentation (Workflows)
+
+- [ ] Each workflow's ALL files read: workflow.yaml, instructions.md, template.md, checklist.md
+- [ ] README.md includes frontmatter with current last-redoc-date
+- [ ] Description is 2-4 paragraphs of technical writer quality
+- [ ] Focuses on DISTINCTIVE features, not BMAD boilerplate conventions
+- [ ] Includes "Usage" section with invocation command
+- [ ] Includes "Inputs" and "Outputs" sections where applicable
+- [ ] Succinct and precise language used throughout
+
+## Leaf-Level Documentation (Agents)
+
+- [ ] Each agent file read completely including XML structure, commands, persona
+- [ ] README.md includes frontmatter with current last-redoc-date
+- [ ] Description is 1-3 paragraphs of technical writer quality
+- [ ] Lists all available commands clearly
+- [ ] Explains when to use this agent
+- [ ] Highlights unique capabilities vs standard agent patterns
+
+## Mid-Level Documentation (Folders)
+
+- [ ] All child README.md files read before generating folder README
+- [ ] Workflows categorized logically if massive folder (>10 items)
+- [ ] Agents categorized by type if massive folder (>10 items)
+- [ ] Catalog documents (WORKFLOWS-CATALOG.md, AGENTS-CATALOG.md) created for massive folders
+- [ ] Catalog documents include frontmatter with last-redoc-date
+- [ ] Folder README.md references catalog if one exists
+- [ ] Folder README.md is succinct (1-2 paragraphs + listings/links)
+- [ ] Notable/commonly-used items highlighted
+
+## Root Module Documentation
+
+- [ ] Module config.yaml read and understood
+- [ ] Workflows and agents folder READMEs read before creating root README
+- [ ] Root README includes frontmatter with current last-redoc-date
+- [ ] Module purpose clearly stated in 2-3 sentences
+- [ ] Links to /workflows/README.md and /agents/README.md included
+- [ ] 2-3 key workflows mentioned with context
+- [ ] 2-3 key agents mentioned with context
+- [ ] Configuration section highlights UNIQUE settings only
+- [ ] Usage section explains invocation patterns
+- [ ] BMAD convention knowledge applied (describes only distinctive aspects)
+
+## Quality Standards
+
+- [ ] All documentation uses proper BMAD terminology
+- [ ] Technical writer quality: clear, concise, professional
+- [ ] No placeholder text or generic descriptions remain
+- [ ] All links are valid and correctly formatted
+- [ ] Frontmatter syntax is correct and dates are current
+- [ ] No redundant explanation of standard BMAD patterns
+
+## Validation & Reporting
+
+- [ ] All planned documentation items created/updated
+- [ ] Frontmatter dates verified as current across all files
+- [ ] File paths and internal links validated
+- [ ] Summary report generated with counts and coverage
+- [ ] Files skipped (if any) documented with reasons
+
+## Git Diff Analysis (Optional Step)
+
+- [ ] last-redoc-date timestamps extracted correctly
+- [ ] Git log queried for changes since last redoc
+- [ ] Modified files identified and reported
+- [ ] Findings presented clearly to user
+
+## Final Validation
+
+- [ ] Documentation Coverage
+  - All README.md files in scope created/updated
+  - Catalog documents created where needed
+  - No documentation gaps identified
+
+- [ ] Execution Quality
+  - Reverse-tree order followed (leaf → root)
+  - Autonomous execution (minimal user prompts)
+  - Only clarification questions asked when truly necessary
+
+- [ ] Output Quality
+  - Technical precision maintained throughout
+  - Succinct descriptions (no verbose explanations)
+  - Professional documentation standards met

package/src/modules/bmb/workflows/redoc/instructions.md

@@ -0,0 +1,255 @@
+# ReDoc Workflow Instructions
+
+<workflow>
+
+<critical>The workflow execution engine is governed by: {project_root}/bmad/core/tasks/workflow.md</critical>
+<critical>You MUST have already loaded and processed: {project_root}/src/modules/bmb/workflows/redoc/workflow.yaml</critical>
+<critical>This is an AUTONOMOUS workflow - minimize user interaction unless clarification is absolutely required</critical>
+
+<step n="1" goal="Load BMAD conventions and initialize">
+<action>Load ALL BMAD convention documents from {bmad_conventions}:
+- agent_architecture.md - Understand agent XML structure and patterns
+- agent_command_patterns.md - Command syntax and activation patterns
+- agent_types.md - Standard agent categories and purposes
+- module_structure.md - Module organization and folder conventions
+- workflow_guide.md - Workflow structure and best practices
+</action>
+
+<action>Internalize these conventions so you can:
+
+- Recognize standard patterns vs unique implementations
+- Describe only what's distinctive about each component
+- Use proper terminology consistently
+- Write with technical precision
+  </action>
+
+<action>Get target path from user:
+
+- Ask: "What do you want to document? (module path, workflow path, agent path, or folder path)"
+- Store as {{target_path}}
+  </action>
+
+<action>Validate target path exists and determine target type:
+
+- Module root (contains config.yaml, /workflows, /agents folders)
+- Workflows folder (contains multiple workflow folders)
+- Agents folder (contains multiple agent .md files)
+- Single workflow folder (contains workflow.yaml)
+- Single agent file (.md)
+  </action>
+
+<action>Store target type as {{target_type}} for conditional processing</action>
+</step>
+
+<step n="2" goal="Analyze directory structure and existing documentation">
+<action>Build complete tree structure of {{target_path}} using Glob and file system tools</action>
+
+<action>Identify all documentation points:
+
+- List all folders requiring README.md files
+- Detect existing README.md files
+- Parse frontmatter from existing READMEs to extract last-redoc-date
+- Calculate documentation depth (how many levels deep)
+  </action>
+
+<action>Create documentation map with execution order (deepest → shallowest):
+
+- Level 0 (deepest): Individual workflow folders, individual agent files
+- Level 1: /workflows folder, /agents folder
+- Level 2 (root): Module root README.md
+  </action>
+
+<action>Detect "massive folders" requiring child catalog documents:
+
+- Threshold: >10 items or complex categorization needed
+- Mark folders for catalog document creation (e.g., WORKFLOWS-CATALOG.md, AGENTS-CATALOG.md)
+  </action>
+
+<critical>Store execution order as {{doc_execution_plan}} - this ensures reverse-tree processing</critical>
+</step>
+
+<step n="3" goal="Process leaf-level documentation" repeat="for-each-leaf-item">
+<action>For each individual workflow folder in execution plan:
+1. Read ALL files completely:
+   - workflow.yaml (metadata, purpose, configuration)
+   - instructions.md (step structure, goals)
+   - template.md (output structure) if exists
+   - checklist.md (validation criteria) if exists
+   - Any supporting data files
+
+2. Synthesize understanding:
+   - Core purpose and use case
+   - Input requirements
+   - Output produced
+   - Unique characteristics (vs standard BMAD workflow patterns)
+   - Key steps or special features
+
+3. Generate/update README.md:
+   - Add frontmatter: `---\nlast-redoc-date: {{date}}\n---\n`
+   - Write 2-4 paragraph technical description
+   - Include "Usage" section with invocation command
+   - Include "Inputs" section if applicable
+   - Include "Outputs" section
+   - Be succinct and precise - technical writer quality
+   - Focus on DISTINCTIVE features, not boilerplate
+
+4. Save README.md to workflow folder
+   </action>
+
+<action>For each individual agent file in execution plan:
+
+1. Read agent definition file completely:
+   - XML structure and metadata
+   - Commands and their purposes
+   - Activation patterns
+   - Persona and communication style
+   - Critical actions and workflows invoked
+
+2. Synthesize understanding:
+   - Agent purpose and role
+   - Available commands
+   - When to use this agent
+   - Unique capabilities
+
+3. Generate/update README.md (or agent-name-README.md if in shared folder):
+   - Add frontmatter: `---\nlast-redoc-date: {{date}}\n---\n`
+   - Write 1-3 paragraph technical description
+   - Include "Commands" section listing available commands
+   - Include "Usage" section
+   - Focus on distinctive features
+
+4. Save README.md
+   </action>
+
+<check>If clarification needed about purpose or unique features → Ask user briefly, then continue</check>
+</step>
+
+<step n="4" goal="Process mid-level folder documentation" if="target_type requires folder docs">
+<action>For /workflows folder:
+1. Read ALL workflow README.md files created in Step 3
+2. Categorize workflows by purpose/type if folder is massive (>10 workflows):
+   - Document generation workflows
+   - Action workflows
+   - Meta-workflows
+   - Interactive workflows
+
+3. If massive folder detected:
+   - Create WORKFLOWS-CATALOG.md with categorized listings
+   - Each entry: workflow name, 1-sentence description, link to folder
+   - Add frontmatter with last-redoc-date
+
+4. Generate/update /workflows/README.md:
+   - Add frontmatter: `---\nlast-redoc-date: {{date}}\n---\n`
+   - High-level summary of workflow collection
+   - If catalog exists: reference it
+   - If not massive: list all workflows with brief descriptions and links
+   - Highlight notable or commonly-used workflows
+   - Keep succinct (1-2 paragraphs + list)
+
+5. Save README.md
+   </action>
+
+<action>For /agents folder:
+
+1. Read ALL agent README.md files
+2. Categorize agents by type if massive folder (>10 agents):
+   - Task agents
+   - Meta agents
+   - Specialized agents
+   - Utility agents
+
+3. If massive folder detected:
+   - Create AGENTS-CATALOG.md with categorized listings
+   - Each entry: agent name, 1-sentence description, link
+   - Add frontmatter with last-redoc-date
+
+4. Generate/update /agents/README.md:
+   - Add frontmatter: `---\nlast-redoc-date: {{date}}\n---\n`
+   - High-level summary of agent collection
+   - If catalog exists: reference it
+   - If not massive: list all agents with brief descriptions
+   - Highlight key agents and their purposes
+   - Keep succinct
+
+5. Save README.md
+   </action>
+   </step>
+
+<step n="5" goal="Process root module documentation" if="target_type is module root">
+<action>For module root README.md:
+1. Read module config.yaml for metadata and configuration
+2. Read /workflows/README.md and /agents/README.md created in Step 4
+3. Identify module's unique purpose within BMAD ecosystem
+
+4. Generate/update module README.md:
+   - Add frontmatter: `---\nlast-redoc-date: {{date}}\n---\n`
+
+   Structure:
+   - # Module Name
+   - **Purpose**: 2-3 sentence high-level module purpose
+   - **Overview**: 1-2 paragraphs describing what this module provides
+
+   - ## Workflows
+     - Link to /workflows/README.md with 1-sentence summary
+     - Mention count and highlight 2-3 key workflows
+
+   - ## Agents
+     - Link to /agents/README.md with 1-sentence summary
+     - Mention count and highlight 2-3 key agents
+
+   - ## Configuration
+     - Notable config.yaml settings if unique/important
+     - Reference paths and conventions
+
+   - ## Usage
+     - How to invoke workflows or agents from this module
+     - Prerequisites if any
+
+   Focus on UNIQUE aspects using BMAD convention knowledge:
+   - Don't explain standard BMAD patterns
+   - Highlight what makes THIS module distinctive
+   - Use proper BMAD terminology
+
+5. Save README.md to module root
+   </action>
+   </step>
+
+<step n="6" goal="Validation and summary report">
+<action>Verify all planned documentation was created/updated:
+- Check each item in {{doc_execution_plan}}
+- Confirm frontmatter dates are current
+- Validate file paths and links
+</action>
+
+<action>Generate summary report showing:
+
+- Target documented: {{target_path}}
+- Target type: {{target_type}}
+- Documentation files created/updated (count and list)
+- Any catalog files created
+- Files skipped or requiring manual review (if any)
+- Coverage: X% of items documented
+  </action>
+
+<action>Display summary to user</action>
+</step>
+
+<step n="7" goal="Optional git diff analysis" optional="true">
+<ask>Would you like to see what changed since the last redoc run? [y/n]</ask>
+
+<action if="user_response == 'y'">
+For each README with last-redoc-date frontmatter:
+1. Extract last-redoc-date timestamp
+2. Use git log to find files modified since that date in the documented folder
+3. Highlight files that changed but may need documentation updates
+4. Report findings to user
+</action>
+</step>
+
+<step n="8" goal="Completion">
+<action>Confirm autonomous workflow execution complete</action>
+<action>Provide path to all updated documentation</action>
+<action>Suggest next steps if needed (e.g., "Run redoc on parent module to update references")</action>
+</step>
+
+</workflow>

package/src/modules/bmb/workflows/redoc/workflow.yaml

@@ -0,0 +1,33 @@
+# ReDoc - Reverse-Tree Documentation Engine
+name: "redoc"
+description: "Autonomous documentation system that maintains module, workflow, and agent documentation using a reverse-tree approach (leaf folders first, then parents). Understands BMAD conventions and produces technical writer quality output."
+author: "BMad"
+
+# Critical variables
+config_source: "{project-root}/bmad/bmb/config.yaml"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+date: system-generated
+
+# Required knowledge base - BMAD conventions and patterns
+bmad_conventions:
+  agent_architecture: "{project-root}/src/modules/bmb/workflows/create-agent/agent-architecture.md"
+  agent_command_patterns: "{project-root}/src/modules/bmb/workflows/create-agent/agent-command-patterns.md"
+  agent_types: "{project-root}/src/modules/bmb/workflows/create-agent/agent-types.md"
+  module_structure: "{project-root}/src/modules/bmb/workflows/create-module/module-structure.md"
+  workflow_guide: "{project-root}/src/modules/bmb/workflows/create-workflow/workflow-creation-guide.md"
+
+# Runtime inputs
+target_path: "" # User specifies: module path, workflow path, agent path, or folder path
+
+# Module path and component files
+installed_path: "{project-root}/src/modules/bmb/workflows/redoc"
+template: false # Action workflow - updates files in place
+instructions: "{installed_path}/instructions.md"
+validation: "{installed_path}/checklist.md"
+
+# Configuration
+autonomous: true # Runs without user checkpoints unless clarification needed
+
+# Tool Requirements - Using built-in file system tools
+required_tools: []

package/src/modules/bmm/_module-installer/assets/bmm-kb.md

@@ -0,0 +1 @@
+# BMad Method Master Knowledge Base Index

package/src/modules/bmm/_module-installer/assets/technical-decisions-template.md

@@ -0,0 +1,30 @@
+# Technical Decisions Log
+
+_Auto-updated during discovery and planning sessions - you can also add information here yourself_
+
+## Purpose
+
+This document captures technical decisions, preferences, and constraints discovered during project discussions. It serves as input for architecture.md and solution design documents.
+
+## Confirmed Decisions
+
+<!-- Technical choices explicitly confirmed by the team/user -->
+
+## Preferences
+
+<!-- Non-binding preferences mentioned during discussions -->
+
+## Constraints
+
+<!-- Hard requirements from infrastructure, compliance, or integration needs -->
+
+## To Investigate
+
+<!-- Technical questions that need research or architect input -->
+
+## Notes
+
+- This file is automatically updated when technical information is mentioned
+- Decisions here are inputs, not final architecture
+- Final technical decisions belong in architecture.md
+- Implementation details belong in solutions/\*.md and story context or dev notes.

package/src/modules/bmm/_module-installer/install-menu-config.yaml

@@ -0,0 +1,49 @@
+# BMAD™ Method Core Configuration
+
+code: bmm
+name: "BMM: BMad Method Agile-AI Driven-Development"
+default_selected: true # This module will be selected by default for new installations
+
+prompt:
+  - "Thank you for choosing the BMAD™ Method, your gateway to dreaming, planning"
+  - "and building with real world proven techniques."
+  - "All paths are relative to project root, with no leading slash."
+
+# Variables from Core Config inserted:
+## user_name
+## communication_language
+## output_folder
+
+project_name:
+  prompt: "What is the title of your project you will be working on?"
+  default: "My Project"
+  result: "{value}"
+
+tech_docs:
+  prompt: "Where is Technical Documentation located within the project?"
+  default: "docs"
+  result: "{project-root}/{value}"
+
+dev_story_location:
+  prompt: "Where should development stories be stored?"
+  default: "docs/stories"
+  result: "{project-root}/{value}"
+
+kb_location:
+  prompt: "Where should bmad knowledge base articles be stored?"
+  default: "~/bmad/bmm/kb.md"
+  result: "{value}"
+
+desired_mcp_tools:
+  prompt:
+    - "Which MCP Tools will you be using? (Select all that apply)"
+    - "Note: You will need to install these separately. Bindings will come post ALPHA along with other choices."
+  result: "{value}"
+  multi-select:
+    - "Chrome Official MCP"
+    - "Playwright"
+    - "Context 7"
+    - "Tavily"
+    - "Perplexity"
+    - "Jira"
+    - "Trello"

package/src/modules/bmm/_module-installer/installer.js

@@ -0,0 +1,131 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
+
+/**
+ * BMM Module Installer
+ * Standard module installer function that executes after IDE installations
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from install-menu-config.yaml
+ * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { projectRoot, config, installedIDEs, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🚀 Installing BMM Module...'));
+
+    // Check and create tech_docs directory if configured
+    if (config['tech_docs']) {
+      // Strip {project-root}/ prefix if present
+      const techDocsConfig = config['tech_docs'].replace('{project-root}/', '');
+      const techDocsPath = path.join(projectRoot, techDocsConfig);
+
+      if (await fs.pathExists(techDocsPath)) {
+        // Check if template exists, add if missing
+        const templateDest = path.join(techDocsPath, 'technical-decisions-template.md');
+        if (!(await fs.pathExists(templateDest))) {
+          const templateSource = path.join(__dirname, 'assets', 'technical-decisions-template.md');
+          if (await fs.pathExists(templateSource)) {
+            await fs.copy(templateSource, templateDest);
+            logger.log(chalk.green('✓ Added technical decisions template to existing directory'));
+          }
+        }
+      } else {
+        logger.log(chalk.yellow(`Creating technical documentation directory: ${techDocsConfig}`));
+        await fs.ensureDir(techDocsPath);
+
+        // Copy technical decisions template
+        const templateSource = path.join(__dirname, 'assets', 'technical-decisions-template.md');
+        const templateDest = path.join(techDocsPath, 'technical-decisions-template.md');
+
+        if (await fs.pathExists(templateSource)) {
+          await fs.copy(templateSource, templateDest, { overwrite: false });
+          logger.log(chalk.green('✓ Added technical decisions template'));
+        }
+      }
+    }
+
+    // Create output directory if configured
+    if (config['output_folder']) {
+      // Strip {project-root}/ prefix if present
+      const outputConfig = config['output_folder'].replace('{project-root}/', '');
+      const outputPath = path.join(projectRoot, outputConfig);
+      if (!(await fs.pathExists(outputPath))) {
+        logger.log(chalk.yellow(`Creating output directory: ${outputConfig}`));
+        await fs.ensureDir(outputPath);
+      }
+    }
+
+    // Create dev story location if configured
+    if (config['dev_story_location']) {
+      // Strip {project-root}/ prefix if present
+      const storyConfig = config['dev_story_location'].replace('{project-root}/', '');
+      const storyPath = path.join(projectRoot, storyConfig);
+      if (!(await fs.pathExists(storyPath))) {
+        logger.log(chalk.yellow(`Creating story directory: ${storyConfig}`));
+        await fs.ensureDir(storyPath);
+      }
+    }
+
+    // Handle IDE-specific configurations if needed
+    if (installedIDEs && installedIDEs.length > 0) {
+      logger.log(chalk.cyan(`Configuring BMM for IDEs: ${installedIDEs.join(', ')}`));
+
+      // Add any IDE-specific BMM configurations here
+      for (const ide of installedIDEs) {
+        await configureForIDE(ide, projectRoot, config, logger);
+      }
+    }
+
+    logger.log(chalk.green('✓ BMM Module installation complete'));
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing BMM module: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Configure BMM module for specific platform/IDE
+ * @private
+ */
+async function configureForIDE(ide, projectRoot, config, logger) {
+  // Validate platform code
+  if (!platformCodes.isValidPlatform(ide)) {
+    logger.warn(chalk.yellow(`  Warning: Unknown platform code '${ide}'. Skipping BMM configuration.`));
+    return;
+  }
+
+  const platformName = platformCodes.getDisplayName(ide);
+
+  // Try to load platform-specific handler
+  const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
+
+  try {
+    if (await fs.pathExists(platformSpecificPath)) {
+      const platformHandler = require(platformSpecificPath);
+
+      if (typeof platformHandler.install === 'function') {
+        await platformHandler.install({
+          projectRoot,
+          config,
+          logger,
+          platformInfo: platformCodes.getPlatform(ide), // Pass platform metadata
+        });
+      }
+    } else {
+      // No platform-specific handler for this IDE
+      logger.log(chalk.dim(`  No BMM-specific configuration for ${platformName}`));
+    }
+  } catch (error) {
+    logger.warn(chalk.yellow(`  Warning: Could not load BMM platform-specific handler for ${platformName}: ${error.message}`));
+  }
+}
+
+module.exports = { install };

package/src/modules/bmm/_module-installer/platform-specifics/claude-code.js

@@ -0,0 +1,35 @@
+const chalk = require('chalk');
+
+/**
+ * BMM Platform-specific installer for Claude Code
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from install-menu-config.yaml
+ * @param {Object} options.logger - Logger instance for output
+ * @param {Object} options.platformInfo - Platform metadata from global config
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { logger, platformInfo } = options;
+  // projectRoot and config available for future use
+
+  try {
+    const platformName = platformInfo ? platformInfo.name : 'Claude Code';
+    logger.log(chalk.cyan(`  BMM-${platformName} Specifics installed`));
+
+    // Add Claude Code specific BMM configurations here
+    // For example:
+    // - Custom command configurations
+    // - Agent party configurations
+    // - Workflow integrations
+    // - Template mappings
+
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing BMM Claude Code specifics: ${error.message}`));
+    return false;
+  }
+}
+
+module.exports = { install };

package/src/modules/bmm/_module-installer/platform-specifics/windsurf.js

@@ -0,0 +1,32 @@
+const chalk = require('chalk');
+
+/**
+ * BMM Platform-specific installer for Windsurf
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from install-menu-config.yaml
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { logger } = options;
+  // projectRoot and config available for future use
+
+  try {
+    logger.log(chalk.cyan('  BMM-Windsurf Specifics installed'));
+
+    // Add Windsurf specific BMM configurations here
+    // For example:
+    // - Custom cascades
+    // - Workflow adaptations
+    // - Template configurations
+
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing BMM Windsurf specifics: ${error.message}`));
+    return false;
+  }
+}
+
+module.exports = { install };