bmad-method 4.42.1 → 4.43.1

package/expansion-packs/bmad-godot-game-dev/workflows/game-prototype.yaml

@@ -0,0 +1,213 @@
+workflow:
+  id: godot-game-prototype
+  name: Godot Rapid Prototype Development
+  description: Godot-optimized workflow leveraging the engine's rapid prototyping features - @tool scripts, built-in nodes, CSG geometry, immediate mode GUI, and GDScript's duck typing. Emphasizes Godot's hot reload, in-editor testing, and scene-based iteration for validating game concepts in hours, not days.
+  type: prototype
+  project_types:
+    - godot-game-jam
+    - godot-mechanic-test
+    - godot-shader-demo
+    - godot-physics-sandbox
+    - godot-ui-experiment
+    - godot-multiplayer-test
+  prototype_sequence:
+    - step: concept_definition
+      agent: game-designer
+      duration: 15-30 minutes
+      creates: concept-summary.md
+      notes: Define concept leveraging Godot's strengths - built-in physics (Box2D/Bullet), particle systems, shaders, or procedural generation. Identify which Godot nodes will drive the core mechanic.
+    - step: rapid_design
+      agent: game-designer
+      duration: 30-60 minutes
+      creates: prototype-spec.md
+      requires: concept-summary.md
+      optional_steps:
+        - godot_node_selection
+        - scene_structure_sketch
+        - input_action_mapping
+      notes: Map mechanics to specific Godot nodes (Area2D, CharacterBody2D, RigidBody2D). Define scene hierarchy and signal connections. Plan InputMap actions for immediate responsiveness.
+    - step: technical_planning
+      agent: game-developer
+      duration: 15-30 minutes
+      creates: prototype-architecture.md
+      requires: prototype-spec.md
+      notes: Plan Godot-specific implementation - scene structure, autoload needs, @tool scripts for in-editor testing. Use GDScript for all prototype code (duck typing speeds iteration). Identify built-in nodes to leverage.
+    - step: implementation_stories
+      agent: game-sm
+      duration: 30-45 minutes
+      creates: prototype-stories/
+      requires: prototype-spec.md, prototype-architecture.md
+      notes: Create 3-5 Godot-focused stories - "Create player scene with CharacterBody2D", "Implement _physics_process movement", "Connect Area2D signals for interactions". Each story includes specific node types and Godot methods.
+    - step: iterative_development
+      agent: game-developer
+      duration: varies
+      implements: prototype-stories/
+      notes: Use Godot's hot reload and @tool scripts for real-time iteration. Test in editor with F6 (scene) and F5 (project). Profile with Godot's built-in monitors. Use Remote Debugger for mobile testing. Document which built-in nodes work best.
+  workflow_end:
+    action: prototype_evaluation
+    notes: "Prototype complete. Evaluate core mechanics, gather feedback, and decide next steps: iterate, expand, or archive."
+  game_jam_sequence:
+    - step: jam_concept
+      agent: game-designer
+      duration: 10-15 minutes
+      creates: jam-concept.md
+      notes: Match jam theme to Godot's built-in capabilities. Identify hero nodes (e.g., CPUParticles2D for effects, AudioStreamPlayer2D for dynamic audio). Define InputMap actions.
+    - step: jam_implementation
+      agent: game-developer
+      duration: varies (jam timeline)
+      creates: working-prototype
+      requires: jam-concept.md
+      notes: Build directly in Godot editor. Use built-in nodes, CSG for 3D prototypes, immediate GUI for quick UI. Leverage Godot's animation player for juice. Export to HTML5 for easy sharing. Keep scenes under 100 nodes for performance.
+  jam_workflow_end:
+    action: jam_submission
+    notes: Submit to game jam. Capture lessons learned and consider post-jam development if concept shows promise.
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Prototype Project] --> B{Development Context?}
+        B -->|Standard Prototype| C[game-designer: concept-summary.md]
+        B -->|Game Jam| D[game-designer: jam-concept.md]
+
+        C --> E[game-designer: prototype-spec.md]
+        E --> F[game-developer: prototype-architecture.md]
+        F --> G[game-sm: create prototype stories]
+        G --> H[game-developer: iterative implementation]
+        H --> I[Prototype Evaluation]
+
+        D --> J[game-developer: direct implementation]
+        J --> K[Game Jam Submission]
+
+        E -.-> E1[Optional: quick brainstorming]
+        E -.-> E2[Optional: reference research]
+
+        style I fill:#90EE90
+        style K fill:#90EE90
+        style C fill:#FFE4B5
+        style E fill:#FFE4B5
+        style F fill:#FFE4B5
+        style G fill:#FFE4B5
+        style H fill:#FFE4B5
+        style D fill:#FFB6C1
+        style J fill:#FFB6C1
+    ```
+  godot_specific_features:
+    rapid_prototyping_tools:
+      - Tool scripts for in-editor testing without running
+      - CSG nodes for quick 3D geometry without modeling
+      - Immediate mode drawing for debug visualizations
+      - Built-in placeholder assets (icon.svg, default theme)
+      - Hot reload for GDScript changes
+    prototype_acceleration:
+      - F6 to test current scene instantly
+      - F5 to run full project
+      - Remote debugging on devices
+      - Live scene editing while running
+      - Inspector value tweaking in real-time
+    godot_node_combinations:
+      quick_player: CharacterBody2D + CollisionShape2D + Sprite2D
+      pickup_system: Area2D + signal connections
+      physics_toy: RigidBody2D + joints + constraints
+      particle_effects: CPUParticles2D with built-in parameters
+      ui_prototype: Control + containers + theme variations
+    export_for_testing:
+      - HTML5 export for easy web sharing
+      - One-click APK export for Android testing
+      - Debug export with remote debugger enabled
+      - PCK files for quick distribution
+  decision_guidance:
+    use_prototype_sequence_when:
+      - Testing Godot-specific features (shaders, particles, physics)
+      - Validating scene composition strategies
+      - Experimenting with Godot's node system combinations
+      - Building with Godot's animation tools (AnimationPlayer, AnimationTree)
+      - Testing Godot export targets (HTML5, Mobile, Desktop)
+      - Learning Godot's signal patterns and node communication
+    use_game_jam_sequence_when:
+      - Godot Game Jam participation
+      - Leveraging Godot's rapid development features
+      - Using CSG for quick 3D prototypes
+      - Building with Godot's immediate mode GUI
+      - Testing Godot's networking capabilities quickly
+  godot_prototype_best_practices:
+    godot_rapid_development:
+      - Use @tool scripts to test mechanics in editor without running
+      - Leverage Godot's hot reload for immediate feedback
+      - Build scenes incrementally with F6 (test current scene)
+      - Use placeholder Godot icons and CSG shapes
+    godot_node_leverage:
+      - Start with Godot's template projects when applicable
+      - Use Area2D for all detection/trigger needs
+      - Implement with CharacterBody2D's built-in movement methods
+      - Apply RigidBody2D for physics toys
+      - Use Control nodes with containers for auto-layout UI
+    godot_iteration_tools:
+      - Run scenes directly with F6 during development
+      - Use Godot's remote debugger for device testing
+      - Monitor performance with built-in profiler (not external tools)
+      - Adjust project settings in real-time
+      - Use editor's node property tweaking for balancing
+    godot_prototyping_patterns:
+      - Compose scenes, don't code everything
+      - Signal connections over hard references
+      - Export variables for in-editor tweaking
+      - AnimationPlayer for all timed events
+      - Resource files (.tres) for data-driven design
+  godot_prototype_evaluation:
+    godot_mechanic_validation:
+      - Does the mechanic work well with Godot's physics engine?
+      - Are Godot's built-in nodes sufficient or do we need custom?
+      - Can the mechanic scale with Godot's scene instancing?
+      - Does it perform well on Godot's HTML5 export?
+    godot_technical_assessment:
+      - Draw calls under 1000 (check Godot profiler)
+      - Physics bodies under 200 for mobile targets
+      - Scene tree depth reasonable (<10 levels)
+      - Proper use of Godot's threading if needed
+      - GDScript performance adequate or need C#/GDExtension?
+    godot_expansion_viability:
+      - Can current scene structure support more content?
+      - Are signals and groups set up for scaling?
+      - Is the resource system being used effectively?
+      - Would Godot's multiplayer API support this mechanic?
+      - Are we leveraging Godot's strengths (not fighting it)?
+  post_prototype_options:
+    iterate_and_improve:
+      action: continue_prototyping
+      when: Core mechanic shows promise but needs refinement
+      next_steps: Create new prototype iteration focusing on identified improvements
+    expand_to_full_game:
+      action: transition_to_full_development
+      when: Prototype validates strong game concept
+      next_steps: Use game-dev-greenfield workflow to create full game design and architecture
+    pivot_concept:
+      action: new_prototype_direction
+      when: Current mechanic doesn't work but insights suggest new direction
+      next_steps: Apply learnings to new prototype concept
+    archive_and_learn:
+      action: document_learnings
+      when: Prototype doesn't work but provides valuable insights
+      next_steps: Document lessons learned and move to next prototype concept
+  godot_time_boxing:
+    concept_phase: 30 min - Pick Godot nodes that drive your mechanic
+    design_phase: 1 hour - Sketch scene tree and signal flow
+    planning_phase: 30 min - Set up Godot project with right settings
+    implementation_phase: 2-hour sprints - F6 test after each sprint
+    polish_phase: 1 hour - Godot's animation tools for juice
+  godot_success_metrics:
+    godot_velocity:
+      - First scene running in Godot within 2 hours
+      - Core nodes connected and signaling within 4 hours
+      - Playable build exported (HTML5) within 8 hours
+      - All built-in Godot features identified for mechanic
+    godot_learning:
+      - Which Godot nodes best serve the mechanic
+      - Performance profile from Godot's monitors
+      - Export size and load time benchmarks
+      - Godot-specific optimizations discovered
+      - Editor workflow improvements identified
+  handoff_prompts:
+    concept_to_design: Concept defined with target Godot nodes identified. Create design spec mapping mechanics to Godot's systems.
+    design_to_technical: Design ready with scene structure planned. Create Godot project setup and technical approach.
+    technical_to_stories: Godot architecture defined. Create stories with specific node types and signal connections.
+    stories_to_implementation: Stories specify Godot implementation. Begin building in editor with F6 testing.
+    prototype_to_evaluation: Prototype running in Godot. Check profiler metrics and evaluate for expansion.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "4.42.1",
+  "version": "4.43.1",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

package/release_notes.md

@@ -1,9 +1,12 @@
-## 🚀 What's New in v4.42.1
+## 🚀 What's New in v4.43.1
 
 ### ✨ New Features
 - feat: implement fork-friendly CI/CD with opt-in mechanism (#476)
 - feat(installer): add Codex CLI + Codex Web modes, generate AGENTS.md, inject npm scripts, and docs (#529)
 - feat: add PR validation workflow and contribution checks
+- feat: Add Auggie CLI (Augment Code) Integration (#520)
+- feat: enhance file exclusion capabilities with .bmad-flattenignore support (#531)
+- feat: add iflow cli support to bmad installer.  (#510)
 
 ### 🐛 Bug Fixes
 - fix: update installer version display to show 4.39.0
@@ -12,17 +15,31 @@
 - fix: documentation and trademark updates
 - fix: remove incorrect else branch causing flatten command regression (#452)
 - fix: correct dependency path format in bmad-master agent (#495)
+- fix: Codex options missing from the IDE selection menu (#535)
+- Fixed: "glob" is not defined (#504)
+- fix: Template file extension in validation next story steps (#523)
+- fix: update .gitignore to correct cursor file entry (#485)
+- fix: update workflow file extensions from .md to .yaml in bmad-master.md (#562)
+- fix: Changed title to coding standards section of brownfield architecture template (#564)
 
 ### 📦 Other Changes
 - patch: move script to tools folder
 - typo in README.md (#515)
 - Update dev.md (#491)
 - test: trigger PR validation (#533)
+- docs: remove misplaced Codex section from README
+- Expansion pack doc correction
+- added gemini cli custom commands! (#549)
+- Update ide-setup.js - add missing glob require (#514)
+- Godot Game Dev expansion pack for BMAD (#532)
+- documentation updates
+- remove errant command from readme
 
 ### 🔧 Maintenance
 - chore: bump to 4.39.1 to fix installer version display
 - chore: update project dependencies and development tooling (#508)
 - chore: bump version to 4.42.0 for release
+- chore: sync version to 4.42.1 after release
 
 
 ## 📦 Installation
@@ -31,4 +48,4 @@
 npx bmad-method install
 ```
 
-**Full Changelog**: https://github.com/bmadcode/BMAD-METHOD/compare/v4.39.0...v4.42.1
+**Full Changelog**: https://github.com/bmadcode/BMAD-METHOD/compare/v4.39.0...v4.43.1

package/tools/flattener/ignoreRules.js

@@ -154,9 +154,11 @@ async function parseGitignore(gitignorePath) {
 async function loadIgnore(rootDir, extraPatterns = []) {
   const ig = ignore();
   const gitignorePath = path.join(rootDir, '.gitignore');
+  const flattenIgnorePath = path.join(rootDir, '.bmad-flattenignore');
   const patterns = [
     ...(await readIgnoreFile(gitignorePath)),
     ...DEFAULT_PATTERNS,
+    ...(await readIgnoreFile(flattenIgnorePath)),
     ...extraPatterns,
   ];
   // De-duplicate

package/tools/installer/bin/bmad.js

@@ -49,7 +49,7 @@ program
   .option('-d, --directory <path>', 'Installation directory')
   .option(
     '-i, --ide <ide...>',
-    'Configure for specific IDE(s) - can specify multiple (cursor, claude-code, windsurf, trae, roo, kilo, cline, gemini, qwen-code, github-copilot, codex, codex-web, other)',
+    'Configure for specific IDE(s) - can specify multiple (cursor, claude-code, windsurf, trae, roo, kilo, cline, gemini, qwen-code, github-copilot, codex, codex-web, auggie-cli, iflow-cli, other)',
   )
   .option(
     '-e, --expansion-packs <packs...>',
@@ -397,6 +397,7 @@ async function promptInstallation() {
         choices: [
           { name: 'Cursor', value: 'cursor' },
           { name: 'Claude Code', value: 'claude-code' },
+          { name: 'iFlow CLI', value: 'iflow-cli' },
           { name: 'Windsurf', value: 'windsurf' },
           { name: 'Trae', value: 'trae' }, // { name: 'Trae', value: 'trae'}
           { name: 'Roo Code', value: 'roo' },
@@ -406,6 +407,9 @@ async function promptInstallation() {
           { name: 'Qwen Code', value: 'qwen-code' },
           { name: 'Crush', value: 'crush' },
           { name: 'Github Copilot', value: 'github-copilot' },
+          { name: 'Auggie CLI (Augment Code)', value: 'auggie-cli' },
+          { name: 'Codex CLI', value: 'codex' },
+          { name: 'Codex Web', value: 'codex-web' },
         ],
       },
     ]);
@@ -474,6 +478,38 @@ async function promptInstallation() {
     answers.githubCopilotConfig = { configChoice };
   }
 
+  // Configure Auggie CLI (Augment Code) immediately if selected
+  if (ides.includes('auggie-cli')) {
+    console.log(chalk.cyan('\n📍 Auggie CLI Location Configuration'));
+    console.log(chalk.dim('Choose where to install BMad agents for Auggie CLI access.\n'));
+
+    const { selectedLocations } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedLocations',
+        message: 'Select Auggie CLI command locations:',
+        choices: [
+          {
+            name: 'User Commands (Global): Available across all your projects (user-wide)',
+            value: 'user',
+          },
+          {
+            name: 'Workspace Commands (Project): Stored in repository, shared with team',
+            value: 'workspace',
+          },
+        ],
+        validate: (selected) => {
+          if (selected.length === 0) {
+            return 'Please select at least one location';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    answers.augmentCodeConfig = { selectedLocations };
+  }
+
   // Ask for web bundles installation
   const { includeWebBundles } = await inquirer.prompt([
     {

package/tools/installer/config/install.config.yaml

@@ -28,6 +28,15 @@ ide-configurations:
       # To use BMad agents in Claude Code:
       # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
       # 2. Claude will switch to that agent's persona
+  iflow-cli:
+    name: iFlow CLI
+    rule-dir: .iflow/commands/BMad/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in iFlow CLI:
+      # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
+      # 2. iFlow will switch to that agent's persona
   crush:
     name: Crush
     rule-dir: .crush/commands/BMad/
@@ -78,15 +87,15 @@ ide-configurations:
       # 4. Rules are stored in .clinerules/ directory in your project
   gemini:
     name: Gemini CLI
-    rule-dir: .gemini/bmad-method/
-    format: single-file
-    command-suffix: .md
+    rule-dir: .gemini/commands/BMad/
+    format: multi-file
+    command-suffix: .toml
     instructions: |
       # To use BMad agents with the Gemini CLI:
-      # 1. The installer creates a .gemini/bmad-method/ directory in your project.
-      # 2. It concatenates all agent files into a single GEMINI.md file.
-      # 3. Simply mention the agent in your prompt (e.g., "As *dev, ...").
-      # 4. The Gemini CLI will automatically have the context for that agent.
+      # 1. The installer creates a `BMad` folder in `.gemini/commands`.
+      # 2. This adds custom commands for each agent and task.
+      # 3. Type /BMad:agents:<agent-name> (e.g., "/BMad:agents:dev", "/BMad:agents:pm") or /BMad:tasks:<task-name> (e.g., "/BMad:tasks:create-doc").
+      # 4. The agent will adopt that persona for the conversation or preform the task.
   github-copilot:
     name: Github Copilot
     rule-dir: .github/chatmodes/
@@ -122,6 +131,25 @@ ide-configurations:
       # 3. Simply mention the agent in your prompt (e.g., "As *dev, ...").
       # 4. The Qwen Code CLI will automatically have the context for that agent.
 
+  auggie-cli:
+    name: Auggie CLI (Augment Code)
+    format: multi-location
+    locations:
+      user:
+        name: User Commands (Global)
+        rule-dir: ~/.augment/commands/bmad/
+        description: Available across all your projects (user-wide)
+      workspace:
+        name: Workspace Commands (Project)
+        rule-dir: ./.augment/commands/bmad/
+        description: Stored in your repository and shared with your team
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Auggie CLI (Augment Code):
+      # 1. Type /bmad:agent-name (e.g., "/bmad:dev", "/bmad:pm", "/bmad:architect")
+      # 2. The agent will adopt that persona for the conversation
+      # 3. Commands are available based on your selected location(s)
+
   codex:
     name: Codex CLI
     format: project-memory