enhance_swarm 2.1.0 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96486b70ea6b91dd85a7428f69a134473251a9da3631524231ff6dc666703b01
-  data.tar.gz: 0ab0529529648d4ce97874cd98abaf39e30494793eb5f32e66bf5292d7add096
+  metadata.gz: 7b8c5522c0ed58c3863fddfd4e6f11d0d091440ae2de4b863bfae7e7bece5b6b
+  data.tar.gz: 286889e00e4f50c6100d5012f1320bb06ce6270c6b6b9dbcce2cd26846c1a16c
 SHA512:
-  metadata.gz: 8c3aa14e5be811b9cabeac1444a80845b226a109e39fee236bc00bfc03a9f94d0190e8ff3b7bc1dd27ac6ee6af0629e50128262292b7322313cf8322bb807834
-  data.tar.gz: e929cbad2a991ff4bd879456bef4785012763301fbe37c6f333388deea820e300ff6e5cc573bebc2193223c320e4523d7af242bf041a40b16e18789fd22541ca
+  metadata.gz: 9ed4192cb031f30d8baa2fcd9762ef161e463c23d01b44f14a6c2663dcac11896001a23fc8fb523fd75caf38e63c4d1555523c782c38ae7bc334d82e20ebb93d
+  data.tar.gz: 97aeaaf8afcd9396f6441ae82666759aaa25c545eb693371731a3d991372a25d1c9e84065143aad3a45155d0a58519f830dbfafa9dd6b518d517e045cb23bf27

data/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to EnhanceSwarm will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.1] - 2025-06-30
+
+### 🔧 Critical Bug Fixes
+
+#### 💥 Production Issues Resolved
+- **✅ CRITICAL: Fixed Detached Mode Logging** - Absolute paths prevent log files from disappearing in background processes
+- **✅ CRITICAL: Fixed Bullet Train Super Scaffolding** - Non-interactive printf commands prevent NoMethodError on interactive prompts
+- **✅ Enhanced Non-Interactive Templates** - Comprehensive printf templates for common BT scaffolding patterns
+- **✅ Improved Status Reporting** - Better orchestration monitoring and error handling
+
+#### 🛠️ Technical Improvements
+- **Detached Mode:** Fixed absolute path resolution for `.enhance_swarm/logs/` directory
+- **BT Scaffolding:** Added `printf "y\\n[slug]\\n[icon]\\n"` templates for common Super Scaffolding patterns
+- **Error Handling:** Enhanced subprocess error capture and reporting
+- **Status Monitoring:** Reliable status file writing with working directory context
+
+This patch release ensures production orchestration reliability with proper logging and Bullet Train scaffolding compliance.
+
 ## [2.1.0] - 2025-06-30
 
 ### 🔥 Critical Orchestration Fixes & Production Enhancements

data/PRODUCTION_INSTALL_TEST.md

@@ -0,0 +1,117 @@
+# 🚀 Production Installation & Test Guide - v2.1.0
+
+## ✅ Quick Test with Published Gem
+
+### 1. Install Latest Version
+```bash
+# Install the latest version with all critical fixes
+gem install enhance_swarm
+
+# Verify version 2.1.0+
+enhance-swarm --version
+```
+
+### 2. Create Test Project
+```bash
+# Create fresh Rails app
+rails new enhance_test_production && cd enhance_test_production
+
+# Initialize git (required)
+git init && git add -A && git commit -m "Initial Rails app"
+```
+
+### 3. Run Production Test
+```bash
+# Test detached orchestration (recommended)
+enhance-swarm orchestrate "Create a Contact management system with name, email, phone, company fields and full CRUD operations" --detached
+
+# Monitor progress
+enhance-swarm status
+
+# Watch logs
+tail -f .enhance_swarm/logs/orchestration.log
+```
+
+### 4. Verify Results (2-3 minutes)
+```bash
+# Check completion
+cat .enhance_swarm/logs/orchestration_status.txt
+# Should show: COMPLETED
+
+# Verify files created
+find . -name "*contact*" -type f | head -10
+
+# Check git commit
+git log --oneline -5 | grep "EnhanceSwarm"
+```
+
+## 🚅 Bullet Train Test
+
+### 1. Setup Bullet Train Project
+```bash
+# Clone Bullet Train starter
+git clone https://github.com/bullet-train-co/bullet_train.git bt_production_test
+cd bt_production_test
+
+# Setup (follow BT docs)
+bundle install && yarn install
+rails db:create db:migrate db:seed
+git add -A && git commit -m "Initial BT setup"
+```
+
+### 2. Test with Bullet Train Conventions
+```bash
+# Run orchestration with BT-specific task
+enhance-swarm orchestrate "Create a Project management system using Bullet Train Super Scaffolding with title, description, status, due_date fields" --detached
+
+# Monitor until completion
+enhance-swarm status && tail -f .enhance_swarm/logs/orchestration.log
+```
+
+### 3. Verify Bullet Train Results
+```bash
+# Should create files with:
+# ✅ Proper BT includes (include Projects::Base)
+# ✅ Magic comments (🚅 add associations above)
+# ✅ Tailwind CSS styling (NOT Bootstrap)
+# ✅ Team-scoped architecture
+# ✅ Super Scaffolding patterns
+
+grep -r "include.*Base" app/models/
+grep -r "🚅" app/models/
+grep -r "bg-white\|text-gray" app/views/
+```
+
+## 🎯 Expected Results
+
+### ✅ Success Indicators
+- **Status**: `COMPLETED` in 2-3 minutes
+- **Files**: 10-15 files created including models, controllers, views, migrations
+- **Quality**: Professional validations, responsive UI, comprehensive tests
+- **Git**: Automatic commit with descriptive message
+- **Styling**: Tailwind CSS for BT, Bootstrap/Tailwind for Rails
+
+### ⚠️ Troubleshooting
+```bash
+# If orchestration hangs
+enhance-swarm status
+
+# Check for errors
+cat .enhance_swarm/logs/orchestration.log | grep ERROR
+
+# Verify Claude CLI
+claude --version
+```
+
+---
+
+## 📋 What's New in v2.1.0
+
+✅ **Detached Mode**: Non-blocking orchestration with `--detached`  
+✅ **Status Monitoring**: Real-time progress with `enhance-swarm status`  
+✅ **Worktree Merging**: Agents properly merge changes to main project  
+✅ **Tailwind Default**: Bullet Train projects use Tailwind CSS automatically  
+✅ **Enhanced Prompting**: Mandatory Super Scaffolding for BT projects  
+✅ **Timeout Controls**: 120-second timeouts with proper error handling  
+
+**🚀 Ready for production with `gem install enhance_swarm`!**

data/README.md

@@ -18,6 +18,7 @@ EnhanceSwarm transforms Claude into a sophisticated development team that works
 ### Installation
 ```bash
 gem install enhance_swarm
+# Version 2.1.0+ required for critical fixes and detached mode
 ```
 
 ### Initialize in Your Project

data/lib/enhance_swarm/agent_spawner.rb

@@ -350,15 +350,28 @@ module EnhanceSwarm
         ```
         
         **🚨 MANDATORY EXECUTION SEQUENCE - NO EXCEPTIONS:**
-        1. FIRST: bundle exec rails generate super_scaffold Contact Team name:text_field email:email_field phone:phone_field company:text_field
+        1. FIRST: Use Super Scaffolding with non-interactive mode:
+           ```bash
+           # For Contact model:
+           printf "y\\ncontacts\\nti-address-book\\n" | bundle exec rails generate super_scaffold Contact Team name:text_field email:email_field phone:phone_field company:text_field
+           
+           # For Project model:
+           printf "y\\nprojects\\nti-view-grid\\n" | bundle exec rails generate super_scaffold Project Team title:text_field description:trix_editor status:buttons due_date:date_field
+           
+           # Template for any model:
+           printf "y\\n[plural_slug]\\n[icon_name]\\n" | bundle exec rails generate super_scaffold [ModelName] Team [field:type ...]
+           ```
+           - Auto-answers: navbar=yes, slug=[plural_slug], icon=[icon_name]
+           - Common icons: ti-address-book, ti-view-grid, ti-users, ti-folder, ti-calendar
         2. THEN: bundle exec rails db:migrate
         3. THEN: bundle exec rails test (to verify everything works)
-        4. ONLY IF NEEDED: bin/resolve Contacts::Base --eject --open (for customization)
+        4. ONLY IF NEEDED: bin/resolve Projects::Base --eject --open (for customization)
         5. Configure config/models/roles.yml with proper permissions
         
         **🚨 CRITICAL: You MUST actually run these commands using the Bash tool - not just describe them!**
         **🚨 DO NOT create manual Rails models/controllers - ONLY use Super Scaffolding!**
         **🚨 NEVER skip step 1 - Super Scaffolding is MANDATORY for Bullet Train projects!**
+        **🚨 ALWAYS use printf with proper answers for interactive prompts!**
         
         **API Routes (add to config/routes/api/v1.rb):**
         ```ruby

data/lib/enhance_swarm/cli.rb

@@ -652,30 +652,31 @@ module EnhanceSwarm
           require '#{File.expand_path('../../enhance_swarm', __FILE__)}'
           
           task_desc = ENV['ENHANCE_SWARM_TASK']
+          working_dir = '#{Dir.pwd}'
           
           begin
-            Dir.chdir('#{Dir.pwd}')
+            Dir.chdir(working_dir)
             
-            File.write('.enhance_swarm/logs/orchestration_status.txt', 'RUNNING')
-            File.write('.enhance_swarm/logs/orchestration.log', 
-              "\#{Time.now}: Coordinator starting\\n", mode: 'a')
+            File.write("\#{working_dir}/.enhance_swarm/logs/orchestration_status.txt", 'RUNNING')
+            File.write("\#{working_dir}/.enhance_swarm/logs/orchestration.log", 
+              "\#{Time.now}: Coordinator starting in \#{working_dir}\\n", mode: 'a')
             
             coordinator = EnhanceSwarm::TaskCoordinator.new
             coordinator.coordinate_task(task_desc)
             
-            File.write('.enhance_swarm/logs/orchestration_status.txt', 'COMPLETED')
-            File.write('.enhance_swarm/logs/orchestration.log', 
+            File.write("\#{working_dir}/.enhance_swarm/logs/orchestration_status.txt", 'COMPLETED')
+            File.write("\#{working_dir}/.enhance_swarm/logs/orchestration.log", 
               "\#{Time.now}: Orchestration completed successfully\\n", mode: 'a')
               
           rescue => e
-            File.write('.enhance_swarm/logs/orchestration_status.txt', "FAILED: \#{e.message}")
-            File.write('.enhance_swarm/logs/orchestration.log', 
+            File.write("\#{working_dir}/.enhance_swarm/logs/orchestration_status.txt", "FAILED: \#{e.message}")
+            File.write("\#{working_dir}/.enhance_swarm/logs/orchestration.log", 
               "\#{Time.now}: ERROR: \#{e.message}\\n\#{e.backtrace.first(3).join('\\n')}\\n", mode: 'a')
           end
         RUBY
         chdir: Dir.pwd,
-        out: '.enhance_swarm/logs/orchestration.log',
-        err: '.enhance_swarm/logs/orchestration.log'
+        out: File.join(Dir.pwd, '.enhance_swarm/logs/orchestration.log'),
+        err: File.join(Dir.pwd, '.enhance_swarm/logs/orchestration.log')
       )
       
       # Store PID and detach

data/lib/enhance_swarm/task_coordinator.rb

@@ -20,19 +20,37 @@ module EnhanceSwarm
     end
 
     def coordinate_task(description)
-      Logger.info("🎯 Starting intelligent task coordination: #{description}")
+      Logger.info("🎯 ENHANCE SWARM TASK COORDINATOR ACTIVATED")
+      Logger.info("📋 Master Task: #{description}")
+      Logger.info("🔍 Beginning intelligent task analysis and decomposition...")
       
       # 1. Analyze project context
+      Logger.info("🔬 PHASE 1: Project Context Analysis")
       @project_analyzer.analyze
       project_context = @project_analyzer.generate_smart_defaults
       
+      project_type = project_context[:project_type] || 'Generic'
+      tech_stack = project_context[:technology_stack]&.join(', ') || 'Unknown'
+      Logger.info("   📊 Detected: #{project_type} project using #{tech_stack}")
+      
       # 2. Break down task into specialized subtasks
+      Logger.info("🧩 PHASE 2: Intelligent Task Decomposition")
       subtasks = decompose_task(description, project_context)
+      Logger.info("   ⚡ Decomposed into #{subtasks.length} specialized agent tasks")
+      subtasks.each_with_index do |task, i|
+        Logger.info("      #{i+1}. #{task[:role].upcase}: #{task[:description]}")
+      end
       
       # 3. Create dependency-aware execution plan
+      Logger.info("🗺️  PHASE 3: Dependency-Aware Execution Planning")
       execution_plan = create_execution_plan(subtasks)
+      phases = execution_plan[:phases].length
+      total_agents = execution_plan[:phases].sum { |p| p[:tasks].length }
+      Logger.info("   🎯 Generated #{phases}-phase execution plan with #{total_agents} coordinated agents")
       
       # 4. Execute plan with coordination
+      Logger.info("🚀 PHASE 4: Multi-Agent Orchestration Launch")
+      Logger.info("═" * 60)
       execute_coordinated_plan(execution_plan)
     end
 
@@ -538,71 +556,134 @@ module EnhanceSwarm
     end
 
     def execute_coordinated_plan(plan)
-      Logger.info("🚀 Executing coordinated plan with #{plan[:phases].length} phases")
+      Logger.info("🎯 MULTI-AGENT ORCHESTRATION STARTING")
+      Logger.info("📋 Execution Plan: #{plan[:phases].length} phases with #{plan[:phases].sum { |p| p[:tasks].length }} specialized agents")
+      
+      # Show complete coordination plan
+      plan[:phases].each_with_index do |phase, i|
+        agent_roles = phase[:tasks].map { |t| "#{t[:role].upcase}" }.join(", ")
+        Logger.info("   Phase #{i + 1}: [#{agent_roles}] - #{phase[:description]}")
+      end
+      Logger.info("🤖 Agent specializations defined, beginning coordinated execution...")
+      Logger.info("")
       
       plan[:phases].each_with_index do |phase, index|
-        Logger.info("📍 Phase #{index + 1}: #{phase[:description]}")
+        Logger.info("🚀 PHASE #{index + 1} ACTIVATION: #{phase[:description]}")
+        agent_count = phase[:tasks].length
+        agent_list = phase[:tasks].map { |t| "#{t[:role].upcase} Agent" }.join(", ")
+        Logger.info("👥 Deploying #{agent_count} specialized agents: #{agent_list}")
+        
+        # Show dependencies for this phase
+        if index > 0
+          Logger.info("🔗 Dependencies: Awaiting completion of Phase #{index} handoffs")
+        end
         
         # Execute all tasks in this phase (they can run in parallel)
         phase_results = execute_phase(phase[:tasks])
         
         # Validate phase completion before proceeding
         if phase_results.all? { |result| result[:success] }
-          Logger.info("✅ Phase #{index + 1} completed successfully")
+          Logger.info("✅ PHASE #{index + 1} COMPLETE: All agents completed successfully")
+          
+          # Show what each agent accomplished
+          phase_results.each do |result|
+            Logger.info("   📋 #{result[:role].upcase} Agent: #{result[:summary] || 'Task completed'}")
+          end
           
           # CRITICAL: Merge all agent worktree changes back to main project
+          Logger.info("🔄 COORDINATION: Merging agent changes to main project...")
           merge_agent_changes_to_main(phase_results)
+          Logger.info("✅ HANDOFF: Phase #{index + 1} work integrated, ready for next phase")
         else
-          Logger.error("❌ Phase #{index + 1} had failures, stopping execution")
+          Logger.error("❌ PHASE #{index + 1} FAILED: Agent coordination breakdown")
+          failed_agents = phase_results.select { |r| !r[:success] }.map { |r| r[:role].upcase }
+          Logger.error("   🚨 Failed agents: #{failed_agents.join(', ')}")
           break
         end
         
         # Brief pause between phases for coordination
-        sleep(2) if index < plan[:phases].length - 1
+        if index < plan[:phases].length - 1
+          Logger.info("⏸️  COORDINATION PAUSE: Preparing next phase handoff...")
+          sleep(2)
+          Logger.info("")
+        end
       end
       
       # Final cleanup and commit of merged changes
+      Logger.info("🎯 ORCHESTRATION FINALIZATION: Integrating all agent work...")
       finalize_orchestration_results
+      Logger.info("🏆 MULTI-AGENT ORCHESTRATION COMPLETE: Full team coordination successful!")
     end
 
     def execute_phase(tasks)
       results = []
       threads = []
       
-      Logger.info("🚀 Starting parallel execution of #{tasks.length} tasks")
+      Logger.info("⚡ PARALLEL AGENT DEPLOYMENT: Activating #{tasks.length} specialized agents")
+      
+      # Show agent deployment plan
+      tasks.each_with_index do |task, i|
+        dependencies = task[:dependencies]&.empty? ? "None" : task[:dependencies].join(", ")
+        Logger.info("   🤖 #{task[:role].upcase} Agent ##{i+1}: #{task[:description]}")
+        Logger.info("      📋 Dependencies: #{dependencies}")
+      end
+      Logger.info("🚀 Beginning parallel agent execution...")
       
       # Execute tasks in parallel threads
-      tasks.each do |task|
+      tasks.each_with_index do |task, index|
         thread = Thread.new do
           Thread.current[:task_id] = task[:id]
           Thread.current[:role] = task[:role]
           
           begin
+            Logger.info("🟢 AGENT ACTIVATION: #{task[:role].upcase} Agent starting work...")
+            Logger.info("   📌 Task: #{task[:description]}")
+            
             enhanced_prompt = build_enhanced_task_prompt(task)
             
             # Try agent spawning first
+            Logger.info("   🔧 Spawning specialized #{task[:role]} agent in isolated worktree...")
+            start_time = Time.now
+            
             result = @agent_spawner.spawn_agent(
               role: task[:role],
               task: enhanced_prompt,
               worktree: true
             )
             
+            execution_time = (Time.now - start_time).round(1)
+            
             if result
               @agent_assignments[task[:id]] = result
-              Logger.info("✅ Spawned #{task[:role]} agent for task: #{task[:id]}")
-              { task_id: task[:id], success: true, agent_info: result }
+              Logger.info("✅ AGENT SUCCESS: #{task[:role].upcase} Agent completed in #{execution_time}s")
+              Logger.info("   📊 Work completed in isolated environment, ready for integration")
+              { 
+                task_id: task[:id], 
+                role: task[:role],
+                success: true, 
+                agent_info: result,
+                execution_time: execution_time,
+                summary: "Specialized #{task[:role]} work completed successfully"
+              }
             else
               # Fallback to direct execution
-              Logger.warn("⚠️ Agent spawn failed for #{task[:role]}, executing directly")
+              Logger.warn("⚠️  AGENT FALLBACK: #{task[:role]} agent spawn failed, using control agent")
               direct_result = execute_task_directly(task)
               
               if direct_result
-                Logger.info("✅ Control agent completed task directly: #{task[:id]}")
+                Logger.info("✅ CONTROL AGENT: Completed #{task[:role]} task directly in #{execution_time}s")
               else
-                Logger.error("❌ Control agent failed to execute task: #{task[:id]}")
+                Logger.error("❌ AGENT FAILURE: Control agent could not complete #{task[:role]} task")
               end
               
-              { task_id: task[:id], success: direct_result, executed_directly: true }
+              { 
+                task_id: task[:id], 
+                role: task[:role],
+                success: direct_result, 
+                executed_directly: true,
+                execution_time: execution_time,
+                summary: direct_result ? "Control agent handled task" : "Task failed"
+              }
             end
           rescue StandardError => e
             Logger.error("💥 Task #{task[:id]} failed: #{e.message}")

data/lib/enhance_swarm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EnhanceSwarm
-  VERSION = '2.1.0'
+  VERSION = '2.1.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enhance_swarm
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.2
 platform: ruby
 authors:
 - Todd Dickerson
@@ -231,6 +231,7 @@ files:
 - CHANGELOG.md
 - DEPLOYMENT.md
 - LICENSE
+- PRODUCTION_INSTALL_TEST.md
 - README.md
 - Rakefile
 - USAGE_EXAMPLES.md