enhance_swarm 2.0.0 → 2.1.0

data/lib/enhance_swarm/task_coordinator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'timeout'
 require_relative 'logger'
 require_relative 'agent_spawner'
 require_relative 'session_manager'
@@ -314,13 +315,15 @@ module EnhanceSwarm
           "Establish proper API endpoints and webhook architecture"
         ],
         best_practices: [
+          "ALWAYS use magic comments (# 🚅) for Super Scaffolding insertion points",
+          "Models use gem concerns (include ModelNames::Base) - most logic is in gems",
+          "Use BULLET_TRAIN_VERSION constant for version synchronization",
           "Primary model NOT in own namespace (e.g., Subscription, Subscriptions::Plan)",
           "Team-based ownership over user-based ownership",
-          "Use Super Scaffolding for ALL CRUD operations",
-          "Always bin/resolve before customizing framework files",
-          "Configure full plugin ecosystem by default",
-          "Implement CanCanCan roles with inheritance",
-          "Follow shallow nesting for complex routes"
+          "Use bin/resolve --interactive for complex file discovery",
+          "Follow shallow nesting with namespace :v1 for API routes",
+          "Configure real BT roles structure with manageable_roles",
+          "Use bin/configure and bin/setup for project initialization"
         ],
         shared_knowledge: "You are the expert on Bullet Train architecture and must establish the foundation correctly for other agents to build upon"
       }
@@ -546,6 +549,9 @@ module EnhanceSwarm
         # Validate phase completion before proceeding
         if phase_results.all? { |result| result[:success] }
           Logger.info("✅ Phase #{index + 1} completed successfully")
+          
+          # CRITICAL: Merge all agent worktree changes back to main project
+          merge_agent_changes_to_main(phase_results)
         else
           Logger.error("❌ Phase #{index + 1} had failures, stopping execution")
           break
@@ -554,39 +560,79 @@ module EnhanceSwarm
         # Brief pause between phases for coordination
         sleep(2) if index < plan[:phases].length - 1
       end
+      
+      # Final cleanup and commit of merged changes
+      finalize_orchestration_results
     end
 
     def execute_phase(tasks)
       results = []
+      threads = []
       
-      # Spawn agents for all tasks in this phase
+      Logger.info("🚀 Starting parallel execution of #{tasks.length} tasks")
+      
+      # Execute tasks in parallel threads
       tasks.each do |task|
-        enhanced_prompt = build_enhanced_task_prompt(task)
-        
-        result = @agent_spawner.spawn_agent(
-          role: task[:role],
-          task: enhanced_prompt,
-          worktree: true
-        )
-        
-        if result
-          @agent_assignments[task[:id]] = result
-          results << { task_id: task[:id], success: true, agent_info: result }
-          Logger.info("✅ Spawned #{task[:role]} agent for task: #{task[:id]}")
-        else
-          # CRITICAL FIX: Execute task directly when spawning fails
-          Logger.warn("⚠️ Agent spawn failed, control agent executing task directly")
-          direct_result = execute_task_directly(task)
-          results << { task_id: task[:id], success: direct_result, executed_directly: true }
+        thread = Thread.new do
+          Thread.current[:task_id] = task[:id]
+          Thread.current[:role] = task[:role]
           
-          if direct_result
-            Logger.info("✅ Control agent completed task directly: #{task[:id]}")
-          else
-            Logger.error("❌ Control agent failed to execute task: #{task[:id]}")
+          begin
+            enhanced_prompt = build_enhanced_task_prompt(task)
+            
+            # Try agent spawning first
+            result = @agent_spawner.spawn_agent(
+              role: task[:role],
+              task: enhanced_prompt,
+              worktree: true
+            )
+            
+            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 }
+            else
+              # Fallback to direct execution
+              Logger.warn("⚠️ Agent spawn failed for #{task[:role]}, executing directly")
+              direct_result = execute_task_directly(task)
+              
+              if direct_result
+                Logger.info("✅ Control agent completed task directly: #{task[:id]}")
+              else
+                Logger.error("❌ Control agent failed to execute task: #{task[:id]}")
+              end
+              
+              { task_id: task[:id], success: direct_result, executed_directly: true }
+            end
+          rescue StandardError => e
+            Logger.error("💥 Task #{task[:id]} failed: #{e.message}")
+            { task_id: task[:id], success: false, error: e.message }
           end
         end
+        
+        threads << thread
       end
       
+      # Wait for all threads with progress updates
+      Logger.info("⏳ Waiting for parallel task completion...")
+      completed = 0
+      
+      while threads.any?(&:alive?)
+        sleep(5) # Check every 5 seconds
+        previously_completed = completed
+        completed = threads.count { |t| !t.alive? }
+        
+        if completed > previously_completed
+          Logger.info("📊 Progress: #{completed}/#{threads.length} tasks completed")
+        end
+      end
+      
+      # Collect all results
+      threads.each do |thread|
+        results << thread.value
+      end
+      
+      Logger.info("🎯 Phase execution completed: #{results.count { |r| r[:success] }}/#{results.length} successful")
       results
     end
 
@@ -639,21 +685,35 @@ module EnhanceSwarm
         prompt_file.write(execution_prompt)
         prompt_file.close
         
-        # Execute Claude CLI in the current directory with explicit instructions
+        # Execute Claude CLI with timeout controls
         success = false
-        Dir.chdir(Dir.pwd) do
-          # Run Claude and capture both output and success
-          result = system("claude < #{prompt_file.path}")
-          success = result && $?.success?
+        timeout_seconds = 120 # 2 minutes timeout
+        
+        begin
+          Logger.info("🔧 Executing Claude CLI with #{timeout_seconds}s timeout...")
           
-          if success
-            Logger.info("✅ #{task[:role]} task executed successfully")
-            
-            # Commit the changes made by this agent
-            commit_agent_work(task)
-          else
-            Logger.error("❌ #{task[:role]} task execution failed")
+          Timeout::timeout(timeout_seconds) do
+            Dir.chdir(Dir.pwd) do
+              # Run Claude and capture both output and success
+              result = system("claude --dangerously-skip-permissions < #{prompt_file.path}")
+              success = result && $?.success?
+              
+              if success
+                Logger.info("✅ #{task[:role]} task executed successfully")
+                
+                # Commit the changes made by this agent
+                commit_agent_work(task)
+              else
+                Logger.error("❌ #{task[:role]} task execution failed")
+              end
+            end
           end
+        rescue Timeout::Error
+          Logger.error("⏰ #{task[:role]} task timed out after #{timeout_seconds} seconds")
+          success = false
+        rescue StandardError => e
+          Logger.error("💥 #{task[:role]} task failed with error: #{e.message}")
+          success = false
         end
         
         # Clean up temp files
@@ -922,38 +982,39 @@ module EnhanceSwarm
         execution_strategy: <<~STRATEGY,
           🚀 BULLET TRAIN EXECUTION PROTOCOL (v1.24.0) with FULL PLUGIN ECOSYSTEM:
           
-          ## 1. INSTALL ALL BULLET TRAIN PLUGINS (DEFAULT)
-          Essential Gemfile additions:
+          ## 1. BULLET TRAIN GEMFILE WITH VERSION SYNC (REAL STRUCTURE)
+          Essential Gemfile setup:
           ```ruby
-          # Core Framework
-          gem "bullet_train"
-          gem "bullet_train-super_scaffolding"
-          gem "bullet_train-api"
-          gem "bullet_train-fields"
-          gem "bullet_train-themes"
-          gem "bullet_train-themes-light"
-          gem "bullet_train-themes-tailwind_css"
+          # Version sync constant (CRITICAL for BT apps)
+          BULLET_TRAIN_VERSION = "1.24.0"
           
-          # Security & Access Control
-          gem "bullet_train-roles"
-          gem "bullet_train-scope_validator"
-          gem "bullet_train-obfuscates_id"
-          gem "bullet_train-has_uuid"
+          # Core packages
+          gem "bullet_train", BULLET_TRAIN_VERSION
+          gem "bullet_train-super_scaffolding", BULLET_TRAIN_VERSION
+          gem "bullet_train-api", BULLET_TRAIN_VERSION
+          gem "bullet_train-outgoing_webhooks", BULLET_TRAIN_VERSION
+          gem "bullet_train-incoming_webhooks", BULLET_TRAIN_VERSION
+          gem "bullet_train-themes", BULLET_TRAIN_VERSION
+          gem "bullet_train-themes-light", BULLET_TRAIN_VERSION
+          gem "bullet_train-integrations", BULLET_TRAIN_VERSION
+          gem "bullet_train-integrations-stripe", BULLET_TRAIN_VERSION
           
-          # Integrations & Webhooks
-          gem "bullet_train-integrations"
-          gem "bullet_train-integrations-stripe"
-          gem "bullet_train-outgoing_webhooks"
-          gem "bullet_train-incoming_webhooks"
+          # Optional support packages
+          gem "bullet_train-sortable", BULLET_TRAIN_VERSION
+          gem "bullet_train-obfuscates_id", BULLET_TRAIN_VERSION
           
-          # Utilities
-          gem "bullet_train-sortable"
-          gem "bullet_train-routes"
-          gem "bullet_train-serializers"
+          # Core dependencies (keep version sync)
+          gem "bullet_train-fields", BULLET_TRAIN_VERSION
+          gem "bullet_train-has_uuid", BULLET_TRAIN_VERSION
+          gem "bullet_train-roles", BULLET_TRAIN_VERSION
+          gem "bullet_train-scope_validator", BULLET_TRAIN_VERSION
+          gem "bullet_train-super_load_and_authorize_resource", BULLET_TRAIN_VERSION
+          gem "bullet_train-themes-tailwind_css", BULLET_TRAIN_VERSION
           
-          # Billing & Stripe (formerly paid, now free)
-          gem "bullet_train-billing"
-          gem "bullet_train-billing-stripe"
+          # Additional essentials
+          gem "devise"
+          gem "pagy"
+          gem "sidekiq"
           ```
           
           ## 2. GEM UNBUNDLING AWARENESS & FILE RESOLUTION
@@ -971,17 +1032,38 @@ module EnhanceSwarm
           - Look for gem paths in error messages
           - Scan framework concerns: include ModelNameBase
           
-          ## 3. SUPER SCAFFOLDING WITH ANDREW CULVER'S BEST PRACTICES
-          **Namespacing Rules (Culver Convention):**
-          - ✅ Primary model NOT in own namespace: Subscription, Subscriptions::Plan
-          - ❌ Never: Subscriptions::Subscription
-          - Use simple associations within namespace: belongs_to :question (not :surveys_question)
+          ## 3. MAGIC COMMENTS & GEM CONCERNS (REAL BT PATTERN)
+          🔍 **CRITICAL: Use magic comments for Super Scaffolding insertion points**
           
-          **Scaffolding Commands:**
+          **Model Pattern (EXACT structure):**
+          ```ruby
+          class ModelName < ApplicationRecord
+            include ModelNames::Base  # Gem concern with most logic
+            include Webhooks::Outgoing::TeamSupport
+            # 🚅 add concerns above.
+            
+            # 🚅 add belongs_to associations above.
+            # 🚅 add has_many associations above.
+            # 🚅 add oauth providers above.
+            # 🚅 add has_one associations above.
+            # 🚅 add scopes above.
+            # 🚅 add validations above.
+            # 🚅 add callbacks above.
+            # 🚅 add delegations above.
+            # 🚅 add methods above.
+          end
+          ```
+          
+          **Super Scaffolding Commands:**
           - rails generate super_scaffold ModelName Team field:field_type
           - rails generate super_scaffold:field ModelName new_field:field_type
           - rails generate super_scaffold:join_model --help for many-to-many
           
+          **Namespacing Rules (Culver Convention):**
+          - ✅ Primary model NOT in own namespace: Subscription, Subscriptions::Plan
+          - ❌ Never: Subscriptions::Subscription
+          - Use simple associations within namespace: belongs_to :question (not :surveys_question)
+          
           ## 4. TEAM-CENTRIC ARCHITECTURE (Culver Philosophy)
           "Most domain models should belong to a team, not a user"
           - Model resources as team-based by default
@@ -989,17 +1071,41 @@ module EnhanceSwarm
           - Assign entities to memberships, not users directly
           - Enable collaborative access over individual ownership
           
-          ## 5. ROLE SYSTEM CONFIGURATION
+          ## 5. ROLE SYSTEM CONFIGURATION (REAL BT STRUCTURE)
           **config/models/roles.yml setup:**
           ```yaml
-          default: []
+          default:
+            models:
+              Team: read
+              Membership:
+                - read
+                - search
+              Platform::Application: read
+              Webhooks::Outgoing::Endpoint: manage
+              Webhooks::Outgoing::Event: read
+              Invitation:
+                - read
+                - create
+                - destroy
+          
           editor:
-            includes: default
             models:
-              - Project
+              YourModel::TangibleThing: manage
+              YourModel::CreativeConcept:
+                - read
+                - update
+          
           admin:
-            includes: [default, editor]
-            global: true
+            includes:
+              - editor
+            manageable_roles:
+              - admin
+              - editor
+            models:
+              Team: manage
+              Membership: manage
+              YourModel::CreativeConcept: manage
+              Platform::Application: manage
           ```
           
           ## 6. BILLING & STRIPE INTEGRATION
@@ -1013,13 +1119,51 @@ module EnhanceSwarm
           - bullet_train-incoming_webhooks for external service integration
           - JSON:API compliant webhook payloads
           
-          🎯 BULLET TRAIN SPECIFIC COMMANDS WITH FULL ECOSYSTEM:
-          - bundle install (with all plugins)
-          - rails generate super_scaffold Project Team name:text_field
-          - bin/resolve ProjectsController --eject --open
-          - bin/resolve shared/form_with_fields --eject
-          - Write("config/models/roles.yml", role_configuration)
-          - Configure Stripe: rails credentials:edit
+          🎯 BULLET TRAIN SPECIFIC COMMANDS (REAL BT WORKFLOW):
+          **Project Setup:**
+          - bundle install (all plugins with version sync)
+          - bin/configure (initial BT setup)
+          - bin/setup (database and assets)
+          
+          **Super Scaffolding Workflow:**
+          - rails generate super_scaffold Project Team name:text_field description:trix_editor
+          - bin/resolve Projects::Base --eject --open (if customization needed)
+          - bin/resolve account/projects/_form --eject (for view customization)
+          
+          **File Creation with Magic Comments:**
+          - Write("app/models/project.rb", model_with_magic_comments)
+          - Write("config/models/roles.yml", real_bt_roles_structure)  
+          - Write("config/routes/api/v1.rb", shallow_nested_routes)
+          
+          ## 8. 🎨 TAILWIND CSS STYLING (BULLET TRAIN DEFAULT)
+          **CRITICAL: Use Tailwind CSS - NOT Bootstrap or custom CSS**
+          ```erb
+          <!-- Example BT Tailwind patterns -->
+          <div class="bg-white shadow-sm rounded-lg p-6">
+            <h2 class="text-lg font-semibold text-gray-900 mb-4">Projects</h2>
+            <div class="space-y-4">
+              <% @projects.each do |project| %>
+                <div class="border border-gray-200 rounded-md p-4 hover:bg-gray-50">
+                  <h3 class="font-medium text-gray-900"><%= project.title %></h3>
+                  <p class="text-sm text-gray-600 mt-1"><%= project.description %></p>
+                </div>
+              <% end %>
+            </div>
+          </div>
+          ```
+          
+          **BT Tailwind Best Practices:**
+          - Use BT's design tokens: bg-white, text-gray-900, border-gray-200
+          - Follow BT responsive patterns: sm:, md:, lg:, xl:
+          - Use BT component utilities: space-y-*, divide-y, ring-*
+          - Leverage BT theme classes: .btn, .card, .form-input (Tailwind-based)
+          - NEVER mix Bootstrap classes - BT is pure Tailwind CSS
+          
+          **Essential BT Commands:**
+          - bin/resolve --interactive (for file discovery)
+          - bin/super-scaffold (alias for rails generate super_scaffold)
+          - bin/theme (for theme customization)
+          - bin/hack (for local gem development)
         STRATEGY
         file_structure: %w[
           app/models app/controllers/account app/controllers/api/v1 
@@ -1034,7 +1178,9 @@ module EnhanceSwarm
           'Prefer concerns over full ejection',
           'Full plugin ecosystem utilization',
           'Role-based permissions with inheritance',
-          'Billing and Stripe integration ready'
+          'Billing and Stripe integration ready',
+          'Tailwind CSS styling - NEVER Bootstrap',
+          'BT theme design tokens and components'
         ],
         commands: [
           'bundle install',
@@ -1046,5 +1192,136 @@ module EnhanceSwarm
         ]
       }
     end
+
+    # CRITICAL: Merge agent worktree changes back to main project
+    def merge_agent_changes_to_main(phase_results)
+      Logger.info("🔄 Merging agent changes from worktrees to main project...")
+      
+      merged_count = 0
+      
+      phase_results.each do |result|
+        next unless result[:success] && result[:agent_info]
+        
+        agent_info = result[:agent_info]
+        worktree_path = agent_info[:worktree_path]
+        role = agent_info[:role]
+        
+        if worktree_path && Dir.exist?(worktree_path)
+          begin
+            # Copy all relevant files from worktree to main project
+            merge_worktree_to_main(worktree_path, role)
+            merged_count += 1
+            Logger.info("✅ Merged #{role} agent changes from #{worktree_path}")
+          rescue StandardError => e
+            Logger.error("❌ Failed to merge #{role} agent changes: #{e.message}")
+          end
+        end
+      end
+      
+      Logger.info("🎯 Merged changes from #{merged_count} agents to main project")
+    end
+
+    def merge_worktree_to_main(worktree_path, role)
+      main_dir = Dir.pwd
+      
+      # Define critical directories to sync
+      sync_paths = [
+        'app/',
+        'db/',
+        'config/',
+        'spec/',
+        'test/',
+        'lib/',
+        'Gemfile'
+      ]
+      
+      sync_paths.each do |path|
+        source_path = File.join(worktree_path, path)
+        target_path = File.join(main_dir, path)
+        
+        if File.exist?(source_path)
+          if File.directory?(source_path)
+            # Recursively copy directory contents
+            copy_directory_contents(source_path, target_path, role)
+          else
+            # Copy individual file
+            copy_file_if_newer(source_path, target_path, role)
+          end
+        end
+      end
+    end
+
+    def copy_directory_contents(source_dir, target_dir, role)
+      require 'fileutils'
+      
+      Dir.glob(File.join(source_dir, '**', '*')).each do |source_file|
+        next if File.directory?(source_file)
+        
+        relative_path = source_file.sub(source_dir + '/', '')
+        target_file = File.join(target_dir, relative_path)
+        
+        # Ensure target directory exists
+        FileUtils.mkdir_p(File.dirname(target_file))
+        
+        # Copy file if newer or different
+        copy_file_if_newer(source_file, target_file, role)
+      end
+    end
+
+    def copy_file_if_newer(source_file, target_file, role)
+      require 'fileutils'
+      
+      # Always copy from agents - they have the latest work
+      if File.exist?(source_file)
+        begin
+          FileUtils.cp(source_file, target_file)
+          Logger.debug("📄 Copied #{role}: #{File.basename(target_file)}")
+        rescue StandardError => e
+          Logger.warn("⚠️ Failed to copy #{source_file}: #{e.message}")
+        end
+      end
+    end
+
+    def finalize_orchestration_results
+      Logger.info("🎯 Finalizing orchestration results...")
+      
+      begin
+        # Add all merged changes
+        system("git add -A")
+        
+        # Create comprehensive commit
+        commit_message = "EnhanceSwarm orchestration: Multi-agent implementation complete"
+        result = system("git commit -m '#{commit_message}' 2>/dev/null")
+        
+        if result
+          Logger.info("📝 All orchestration changes committed successfully")
+        else
+          Logger.info("ℹ️ No new changes to commit (agents may have worked in isolation)")
+        end
+        
+        # Clean up completed worktrees
+        cleanup_worktrees
+        
+      rescue StandardError => e
+        Logger.warn("⚠️ Failed to finalize results: #{e.message}")
+      end
+    end
+
+    def cleanup_worktrees
+      worktree_dir = '.enhance_swarm/worktrees'
+      return unless Dir.exist?(worktree_dir)
+      
+      Dir.glob(File.join(worktree_dir, '*')).each do |worktree_path|
+        if Dir.exist?(worktree_path)
+          begin
+            # Remove the worktree using git
+            system("git worktree remove --force #{worktree_path} 2>/dev/null")
+            Logger.debug("🧹 Cleaned up worktree: #{File.basename(worktree_path)}")
+          rescue StandardError => e
+            Logger.warn("⚠️ Failed to cleanup worktree #{worktree_path}: #{e.message}")
+          end
+        end
+      end
+    end
   end
 end

data/lib/enhance_swarm/version.rb

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