enhance_swarm 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efab3e0b7d7a5857a84e8006ba7612488b61256be452dec37db8a4eba7f28477
-  data.tar.gz: 85c815c417227d52c83a066339be608b3b4d0eefd209450fd437afb43fe07f17
+  metadata.gz: 7b8c5522c0ed58c3863fddfd4e6f11d0d091440ae2de4b863bfae7e7bece5b6b
+  data.tar.gz: 286889e00e4f50c6100d5012f1320bb06ce6270c6b6b9dbcce2cd26846c1a16c
 SHA512:
-  metadata.gz: 8e7ef2f29f7cce7692ef55f96a739a002aa7b719811a1fe64fbd8657530c5c622a4ce5fa0ef45267a823743a5eee4a24dd25a62f84a07eefb94e934df4df5502
-  data.tar.gz: ad70ada684db28963f44c030bffb4451a19873b303adb09f07d7c6e9968ebf130718c823e6ef8a93cf13a07ae1cc5b351784f270b24ebeef9e7fb58251e2144b
+  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/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.1'
+  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.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Todd Dickerson