enhance_swarm 1.0.0

data/lib/enhance_swarm/orchestrator.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require_relative 'command_executor'
+require_relative 'retry_handler'
+require_relative 'logger'
+require_relative 'cleanup_manager'
+require_relative 'session_manager'
+require_relative 'agent_spawner'
+require_relative 'process_monitor'
+require_relative 'task_integration'
+
+module EnhanceSwarm
+  class Orchestrator
+    def initialize
+      @config = EnhanceSwarm.configuration
+      @task_manager = TaskManager.new
+      @session_manager = SessionManager.new
+      @agent_spawner = AgentSpawner.new
+      @process_monitor = ProcessMonitor.new
+      @task_integration = TaskIntegration.new
+    end
+
+    def enhance(task_id: nil, dry_run: false, follow: false)
+      puts '🎯 ENHANCE Protocol Initiated'.colorize(:green)
+
+      # Step 1: Identify task
+      task = task_id ? @task_manager.find_task(task_id) : @task_manager.next_priority_task
+      unless task
+        puts 'No tasks available in backlog'.colorize(:yellow)
+        return
+      end
+
+      puts "📋 Task: #{task[:id]} - #{task[:title]}".colorize(:blue)
+
+      if dry_run
+        puts "\n🔍 Dry run - would execute:".colorize(:yellow)
+        show_execution_plan(task)
+        return
+      end
+
+      # Step 2: Create or resume session
+      unless @session_manager.session_exists?
+        @session_manager.create_session(task[:description])
+        puts '📁 Created new session'.colorize(:green)
+      else
+        puts '📁 Resuming existing session'.colorize(:blue)
+      end
+
+      # Step 3: Move task to active
+      @task_manager.move_task(task[:id], 'active')
+      puts '✅ Task moved to active'.colorize(:green)
+
+      # Step 4: Break down and spawn agents with progress tracking
+      agents = break_down_task(task)
+      total_tokens = agents.sum { |agent| ProgressTracker.estimate_tokens_for_operation('spawn_agent') }
+      
+      if follow
+        spawn_agents_with_streaming(agents)
+      else
+        ProgressTracker.track(total_steps: 100, estimated_tokens: total_tokens) do |tracker|
+          # Spawn agents (0-50% progress)
+          spawn_result = spawn_agents(agents, tracker)
+          
+          # Brief monitoring (50-100% progress)
+          monitor_with_progress(tracker, @config.monitor_timeout)
+        end
+      end
+
+      # Step 5: Continue with other work
+      puts "\n💡 Agents working in background. Check back later with:".colorize(:blue)
+      puts '   enhance-swarm status'
+      puts '   enhance-swarm monitor'
+
+      # Return control to user for other work
+    end
+
+    def monitor_with_progress(tracker, timeout_seconds)
+      start_time = Time.now
+      last_check = start_time
+      check_interval = 5 # Check every 5 seconds
+      
+      while (Time.now - start_time) < timeout_seconds
+        elapsed = Time.now - start_time
+        progress = 50 + (elapsed / timeout_seconds * 50).to_i # 50-100% progress
+        
+        # Get current status using built-in monitor
+        status = @process_monitor.status
+        active_count = status[:active_agents]
+        
+        tracker.set_progress(progress,
+                           message: "Monitoring #{active_count} active agents...",
+                           operation: 'monitor',
+                           details: { 
+                             active_agents: active_count,
+                             elapsed: "#{elapsed.round}s"
+                           })
+        
+        sleep(check_interval)
+      end
+      
+      tracker.set_progress(100, message: "Monitoring complete - agents running in background")
+    end
+
+    def spawn_agents_with_streaming(agents)
+      puts "\n🤖 Spawning #{agents.count} agents with live output...".colorize(:yellow)
+      
+      # Use built-in agent spawner
+      spawned_agents = @agent_spawner.spawn_multiple_agents(agents)
+      
+      return if spawned_agents.empty?
+      
+      puts "\n🔴 Live output streaming started for #{spawned_agents.count} agents. Press Ctrl+C to stop watching.\n".colorize(:green)
+      
+      # Start streaming output for all agents
+      begin
+        OutputStreamer.stream_agents(spawned_agents)
+      rescue NameError
+        # Fallback: Use built-in monitoring if OutputStreamer doesn't exist
+        puts "🔍 Switching to built-in monitoring...".colorize(:blue)
+        @process_monitor.watch(interval: 3)
+      end
+    end
+
+    def spawn_single(task:, role:, worktree:)
+      operation_id = "spawn_#{role}_#{Time.now.to_i}"
+      Logger.log_operation(operation_id, 'started', { role: role, worktree: worktree })
+
+      puts "🚀 Spawning #{role} agent...".colorize(:yellow)
+
+      begin
+        # Use built-in agent spawner
+        result = @agent_spawner.spawn_agent(
+          role: role,
+          task: task,
+          worktree: worktree && @config.worktree_enabled
+        )
+        
+        if result
+          puts '✅ Agent spawned successfully'.colorize(:green)
+          puts "   📊 PID: #{result[:pid]}, Role: #{result[:role]}".colorize(:blue)
+          if result[:worktree_path]
+            puts "   📊 Worktree: #{File.basename(result[:worktree_path])}".colorize(:blue)
+          end
+          
+          Logger.log_operation(operation_id, 'success', { role: role, pid: result[:pid] })
+          
+          # Wait a moment and check if the process is still running
+          sleep(1)
+          begin
+            Process.getpgid(result[:pid])
+            puts "   📊 Agent process confirmed running".colorize(:green)
+          rescue Errno::ESRCH
+            puts "   📊 Agent process completed quickly".colorize(:yellow)
+          end
+          
+          result[:pid]
+        else
+          puts "❌ Failed to spawn agent".colorize(:red)
+          puts "   💡 Try running with ENHANCE_SWARM_DEBUG=true for details".colorize(:yellow)
+          Logger.log_operation(operation_id, 'failed', { role: role, error: 'Spawn failed' })
+          false
+        end
+      rescue StandardError => e
+        puts "❌ Failed to spawn agent: #{e.message}".colorize(:red)
+        Logger.log_operation(operation_id, 'failed', { role: role, error: e.message })
+        false
+      end
+    end
+
+    def get_task_management_data
+      @task_integration.get_kanban_data
+    end
+
+    def setup_task_management
+      @task_integration.setup_task_management
+    end
+
+    private
+
+    def break_down_task(task)
+      agents = []
+
+      # Analyze task description to determine needed agents
+      desc = task[:description].downcase
+
+      # Always include QA for any feature work
+      needs_qa = desc.match?(/feature|implement|add|create|build/)
+
+      # Check what types of work are needed
+      needs_ui = desc.match?(/ui|interface|design|template|email|view|component/)
+      needs_backend = desc.match?(/model|database|api|service|migration|business logic/)
+      needs_frontend = desc.match?(/controller|javascript|turbo|stimulus|form/)
+
+      # Build agent list based on analysis
+      agents << { role: 'ux', task: extract_ux_work(task) } if needs_ui
+      agents << { role: 'backend', task: extract_backend_work(task) } if needs_backend
+      agents << { role: 'frontend', task: extract_frontend_work(task) } if needs_frontend
+      agents << { role: 'qa', task: extract_qa_work(task) } if needs_qa
+
+      # If no specific needs detected, spawn a general agent
+      agents << { role: 'general', task: task[:description] } if agents.empty?
+
+      agents
+    end
+
+    def spawn_agents(agents, tracker = nil)
+      if tracker
+        tracker.update_status("Spawning #{agents.count} agents...", operation: 'spawn_agents')
+      else
+        puts "\n🤖 Spawning #{agents.count} agents...".colorize(:yellow)
+      end
+      
+      spawned_agents = []
+      failed_agents = []
+      total_estimated_tokens = agents.sum { |agent| ProgressTracker.estimate_tokens_for_operation('spawn_agent') }
+
+      agents.each_with_index do |agent, index|
+        # Update progress if tracker available
+        if tracker
+          progress = (index.to_f / agents.count * 50).to_i # First 50% for spawning
+          tracker.set_progress(progress, 
+                              message: "Spawning #{agent[:role]} agent...",
+                              agent: agent[:role],
+                              operation: 'spawn')
+        end
+
+        # Add jitter to prevent resource contention
+        sleep(2 + rand(0..2)) if index > 0
+        
+        # Use built-in agent spawner
+        result = @agent_spawner.spawn_agent(
+          role: agent[:role],
+          task: agent[:task],
+          worktree: true
+        )
+        
+        if result
+          spawned_agents << { **agent, pid: result[:pid] }
+          tracker&.add_tokens(ProgressTracker.estimate_tokens_for_operation('spawn_agent'))
+        else
+          failed_agents << agent
+        end
+      end
+
+      if tracker
+        tracker.set_progress(50, 
+                           message: "All agents spawned, monitoring...",
+                           operation: 'monitor')
+      elsif failed_agents.empty?
+        puts '✅ All agents spawned'.colorize(:green)
+      else
+        puts "⚠️ #{spawned_agents.size}/#{agents.size} agents spawned successfully".colorize(:yellow)
+        Logger.warn("Failed to spawn agents: #{failed_agents.map { |a| a[:role] }.join(', ')}")
+      end
+      
+      { spawned: spawned_agents, failed: failed_agents }
+    end
+
+
+    def extract_ux_work(task)
+      "Design and implement UI/UX for: #{task[:description]}"
+    end
+
+    def extract_backend_work(task)
+      "Implement backend logic for: #{task[:description]}"
+    end
+
+    def extract_frontend_work(task)
+      "Implement frontend integration for: #{task[:description]}"
+    end
+
+    def extract_qa_work(task)
+      "Write comprehensive tests for: #{task[:description]}"
+    end
+
+    def sanitize_command(command)
+      # Basic command sanitization - remove shell metacharacters
+      command.to_s.gsub(/[;&|`$\\]/, '').strip
+    end
+
+    def sanitize_argument(arg)
+      # Escape shell metacharacters in arguments
+      require 'shellwords'
+      Shellwords.escape(arg.to_s)
+    end
+    
+    def sanitize_role(role)
+      # Only allow known safe roles
+      allowed_roles = %w[ux backend frontend qa general]
+      role = role.to_s.downcase.strip
+      allowed_roles.include?(role) ? role : 'general'
+    end
+
+    def show_execution_plan(task)
+      agents = break_down_task(task)
+
+      puts "Would spawn #{agents.count} agents:".colorize(:blue)
+      agents.each do |agent|
+        puts "  - #{agent[:role].upcase}: #{agent[:task]}"
+      end
+
+      puts "\nActions that would be executed:"
+      puts "  1. Create or resume agent session"
+      puts "  2. #{sanitize_command(@config.task_move_command)} #{sanitize_argument(task[:id])} active"
+      agents.each_with_index do |agent, index|
+        puts "  #{index + 3}. Spawn #{sanitize_role(agent[:role])} agent with git worktree"
+      end
+      puts "  #{agents.count + 3}. Monitor agent progress"
+    end
+  end
+end

data/lib/enhance_swarm/output_streamer.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'pty'
+
+module EnhanceSwarm
+  class OutputStreamer
+    attr_reader :agent_outputs, :active_agents
+
+    def initialize(max_lines: 10)
+      @max_lines = max_lines
+      @agent_outputs = {}
+      @active_agents = {}
+      @output_mutex = Mutex.new
+      @display_thread = nil
+      @running = false
+    end
+
+    def start_streaming
+      @running = true
+      @display_thread = Thread.new { display_loop }
+    end
+
+    def stop_streaming
+      @running = false
+      @display_thread&.join
+      clear_display
+    end
+
+    def add_agent(agent_id, process_pid, role: 'agent')
+      @output_mutex.synchronize do
+        @active_agents[agent_id] = {
+          pid: process_pid,
+          role: role,
+          start_time: Time.now,
+          status: 'running'
+        }
+        @agent_outputs[agent_id] = {
+          lines: [],
+          last_update: Time.now
+        }
+      end
+      
+      # Start monitoring this agent's output (in real implementation)
+      # start_agent_monitor(agent_id, process_pid)
+    end
+
+    def remove_agent(agent_id, status: 'completed')
+      @output_mutex.synchronize do
+        if @active_agents[agent_id]
+          @active_agents[agent_id][:status] = status
+          @active_agents[agent_id][:end_time] = Time.now
+        end
+      end
+    end
+
+    def add_output_line(agent_id, line)
+      @output_mutex.synchronize do
+        return unless @agent_outputs[agent_id]
+        
+        # Clean and format the line
+        clean_line = clean_output_line(line)
+        return if clean_line.empty?
+        
+        @agent_outputs[agent_id][:lines] << {
+          text: clean_line,
+          timestamp: Time.now
+        }
+        
+        # Keep only recent lines
+        if @agent_outputs[agent_id][:lines].length > @max_lines
+          @agent_outputs[agent_id][:lines].shift
+        end
+        
+        @agent_outputs[agent_id][:last_update] = Time.now
+      end
+    end
+
+    private
+
+    def display_loop
+      while @running
+        render_display
+        sleep(0.1) # 10 FPS update rate
+      end
+    end
+
+    def render_display
+      @output_mutex.synchronize do
+        clear_display
+        
+        # Show active agents summary
+        puts build_agents_summary
+        puts
+        
+        # Show live output for each agent
+        @active_agents.each do |agent_id, agent_info|
+          next unless agent_info[:status] == 'running'
+          render_agent_output(agent_id, agent_info)
+        end
+        
+        # Show completed agents summary
+        completed = @active_agents.select { |_, info| info[:status] != 'running' }
+        if completed.any?
+          puts build_completed_summary(completed)
+        end
+      end
+    end
+
+    def build_agents_summary
+      running = @active_agents.count { |_, info| info[:status] == 'running' }
+      completed = @active_agents.count { |_, info| info[:status] == 'completed' }
+      failed = @active_agents.count { |_, info| info[:status] == 'failed' }
+      
+      summary = "🤖 Agents: #{running} running"
+      summary += ", #{completed} completed".colorize(:green) if completed > 0
+      summary += ", #{failed} failed".colorize(:red) if failed > 0
+      
+      summary
+    end
+
+    def render_agent_output(agent_id, agent_info)
+      role = agent_info[:role]
+      elapsed = Time.now - agent_info[:start_time]
+      
+      # Agent header
+      puts "┌─ #{role_icon(role)} #{role.upcase} Agent (#{format_duration(elapsed)}) #{agent_id[0..7]} ─".ljust(60, '─') + '┐'
+      
+      # Recent output lines
+      output_data = @agent_outputs[agent_id]
+      if output_data[:lines].any?
+        output_data[:lines].last(@max_lines).each do |line_data|
+          age = Time.now - line_data[:timestamp]
+          age_indicator = age < 2 ? '●'.colorize(:green) : age < 10 ? '●'.colorize(:yellow) : '●'.colorize(:light_black)
+          puts "│ #{age_indicator} #{line_data[:text].ljust(55)[0..55]} │"
+        end
+      else
+        puts "│ #{' ' * 57} │"
+        puts "│ #{'No output yet...'.colorize(:light_black).ljust(57)} │"
+      end
+      
+      puts "└#{'─' * 58}┘"
+      puts
+    end
+
+    def build_completed_summary(completed_agents)
+      summary = "\n📋 Completed:"
+      completed_agents.each do |agent_id, info|
+        duration = info[:end_time] - info[:start_time]
+        status_icon = info[:status] == 'completed' ? '✅' : '❌'
+        summary += "\n  #{status_icon} #{info[:role]} (#{format_duration(duration)})"
+      end
+      summary
+    end
+
+    def start_agent_monitor(agent_id, process_pid)
+      Thread.new do
+        begin
+          # Monitor the process output by tailing its log file or stdout
+          # This is a simplified version - in reality you'd need to capture
+          # the actual agent's stdout/stderr
+          monitor_agent_process(agent_id, process_pid)
+        rescue StandardError => e
+          Logger.error("Failed to monitor agent #{agent_id}: #{e.message}")
+        end
+      end
+    end
+
+    def monitor_agent_process(agent_id, process_pid)
+      # Check if process is still running
+      loop do
+        break unless process_running?(process_pid)
+        
+        # Try to read from agent's output (this would need actual implementation)
+        # For now, simulate some output
+        if rand < 0.3 # 30% chance of output per cycle
+          simulate_agent_output(agent_id)
+        end
+        
+        sleep(1)
+      end
+      
+      # Process ended
+      remove_agent(agent_id, status: 'completed')
+    rescue StandardError => e
+      remove_agent(agent_id, status: 'failed')
+      add_output_line(agent_id, "❌ Agent failed: #{e.message}")
+    end
+
+    def process_running?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true # Process exists but we can't signal it
+    end
+
+    def simulate_agent_output(agent_id)
+      # This simulates agent output - replace with actual output capture
+      sample_outputs = [
+        "🔍 Analyzing project structure...",
+        "📁 Reading file: #{['app/models/user.rb', 'config/routes.rb', 'spec/models/user_spec.rb'].sample}",
+        "✅ Found existing #{['authentication', 'user model', 'routes', 'tests'].sample}",
+        "🔧 Generating #{['controller', 'migration', 'view', 'test'].sample}...",
+        "📝 Writing #{['spec/requests/auth_spec.rb', 'app/controllers/sessions_controller.rb', 'app/views/sessions/new.html.erb'].sample}",
+        "🏃 Running #{['rspec', 'rubocop', 'tests'].sample}...",
+        "🎯 Implementing #{['login logic', 'validation', 'error handling'].sample}...",
+        "🔒 Adding security #{['validations', 'sanitization', 'authentication'].sample}..."
+      ]
+      
+      add_output_line(agent_id, sample_outputs.sample)
+    end
+
+    def clean_output_line(line)
+      # Remove ANSI color codes and control characters
+      line.to_s
+          .gsub(/\e\[[0-9;]*m/, '') # Remove ANSI color codes
+          .gsub(/\r\n?/, '') # Remove carriage returns
+          .strip
+          .slice(0, 55) # Limit length
+    end
+
+    def role_icon(role)
+      icons = {
+        'backend' => '🔧',
+        'frontend' => '🎨', 
+        'ux' => '✨',
+        'qa' => '🧪',
+        'general' => '🤖'
+      }
+      icons[role.to_s] || '🤖'
+    end
+
+    def format_duration(seconds)
+      if seconds < 60
+        "#{seconds.round}s"
+      elsif seconds < 3600
+        "#{(seconds / 60).round}m"
+      else
+        "#{(seconds / 3600).round(1)}h"
+      end
+    end
+
+    def clear_display
+      # Move cursor to top and clear screen
+      print "\e[H\e[2J"
+    end
+
+    # Class methods for easy usage
+    def self.stream_agents(agents)
+      streamer = new
+      
+      begin
+        streamer.start_streaming
+        
+        # Add all agents to streamer
+        agents.each do |agent|
+          streamer.add_agent(
+            agent[:id] || "#{agent[:role]}-#{Time.now.to_i}",
+            agent[:pid],
+            role: agent[:role]
+          )
+        end
+        
+        # Wait for user interrupt or all agents to complete
+        trap('INT') { streamer.stop_streaming; exit }
+        
+        loop do
+          active_count = streamer.active_agents.count { |_, info| info[:status] == 'running' }
+          break if active_count == 0
+          
+          sleep(1)
+        end
+        
+      ensure
+        streamer.stop_streaming
+      end
+    end
+  end
+end