enhance_swarm 1.0.0

data/lib/enhance_swarm/resource_manager.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+require_relative 'configuration'
+
+module EnhanceSwarm
+  # Manages system resources and enforces limits for agent spawning
+  class ResourceManager
+    MAX_CONCURRENT_AGENTS = 10
+    MAX_MEMORY_MB = 2048
+    MAX_DISK_MB = 1024
+
+    def initialize
+      @config = EnhanceSwarm.configuration
+    end
+
+    def can_spawn_agent?
+      result = {
+        allowed: true,
+        reasons: []
+      }
+
+      # Check concurrent agent limit
+      current_agents = count_active_agents
+      max_agents = @config.max_concurrent_agents || MAX_CONCURRENT_AGENTS
+      
+      if current_agents >= max_agents
+        result[:allowed] = false
+        result[:reasons] << "Maximum concurrent agents reached (#{current_agents}/#{max_agents})"
+      end
+
+      # Check system memory
+      if memory_usage_too_high?
+        result[:allowed] = false
+        result[:reasons] << "System memory usage too high"
+      end
+
+      # Check disk space
+      if disk_usage_too_high?
+        result[:allowed] = false
+        result[:reasons] << "Insufficient disk space"
+      end
+
+      # Check system load
+      if system_load_too_high?
+        result[:allowed] = false
+        result[:reasons] << "System load too high"
+      end
+
+      result
+    end
+
+    def get_resource_stats
+      {
+        active_agents: count_active_agents,
+        max_agents: @config.max_concurrent_agents || MAX_CONCURRENT_AGENTS,
+        memory_usage_mb: get_memory_usage_mb,
+        disk_usage_mb: get_disk_usage_mb,
+        system_load: get_system_load
+      }
+    end
+
+    def enforce_limits!
+      stats = get_resource_stats
+      
+      if stats[:active_agents] > stats[:max_agents]
+        Logger.warn("Agent limit exceeded: #{stats[:active_agents]}/#{stats[:max_agents]}")
+        cleanup_oldest_agents(stats[:active_agents] - stats[:max_agents])
+      end
+    end
+
+    private
+
+    def count_active_agents
+      # Count running enhance-swarm processes
+      begin
+        ps_output = `ps aux | grep -i enhance-swarm | grep -v grep | wc -l`.strip.to_i
+        # Subtract 1 for the current process
+        [ps_output - 1, 0].max
+      rescue StandardError
+        0
+      end
+    end
+
+    def memory_usage_too_high?
+      current_usage = get_memory_usage_mb
+      max_usage = @config.max_memory_mb || MAX_MEMORY_MB
+      current_usage > max_usage
+    end
+
+    def disk_usage_too_high?
+      current_usage = get_disk_usage_mb
+      max_usage = @config.max_disk_mb || MAX_DISK_MB
+      current_usage > max_usage
+    end
+
+    def system_load_too_high?
+      load_avg = get_system_load
+      # Consider load too high if 1-minute average > number of CPU cores
+      cpu_count = get_cpu_count
+      load_avg > cpu_count * 1.5
+    end
+
+    def get_memory_usage_mb
+      begin
+        # Get RSS memory usage of all enhance-swarm processes
+        ps_output = `ps aux | grep -i enhance-swarm | grep -v grep | awk '{sum += $6} END {print sum}'`.strip.to_i
+        # Convert from KB to MB
+        ps_output / 1024
+      rescue StandardError
+        0
+      end
+    end
+
+    def get_disk_usage_mb
+      begin
+        # Check disk usage of .enhance_swarm directory
+        if Dir.exist?('.enhance_swarm')
+          du_output = `du -sm .enhance_swarm 2>/dev/null | awk '{print $1}'`.strip.to_i
+          return du_output
+        end
+        0
+      rescue StandardError
+        0
+      end
+    end
+
+    def get_system_load
+      begin
+        # Get 1-minute load average
+        uptime_output = `uptime`.strip
+        load_match = uptime_output.match(/load averages?: ([\d.]+)/)
+        load_match ? load_match[1].to_f : 0.0
+      rescue StandardError
+        0.0
+      end
+    end
+
+    def get_cpu_count
+      begin
+        # Get number of CPU cores
+        if RUBY_PLATFORM.include?('darwin') # macOS
+          `sysctl -n hw.ncpu`.strip.to_i
+        else # Linux
+          `nproc`.strip.to_i
+        end
+      rescue StandardError
+        4 # Default fallback
+      end
+    end
+
+    def cleanup_oldest_agents(count)
+      Logger.info("Cleaning up #{count} oldest agents to enforce limits")
+      
+      begin
+        # Get list of enhance-swarm processes sorted by start time
+        ps_output = `ps aux | grep -i enhance-swarm | grep -v grep | sort -k9`
+        pids_to_kill = ps_output.lines.first(count).map do |line|
+          line.split[1].to_i # Get PID
+        end
+
+        pids_to_kill.each do |pid|
+          begin
+            Process.kill('TERM', pid)
+            Logger.info("Terminated agent process: #{pid}")
+          rescue Errno::ESRCH
+            # Process already terminated
+          rescue StandardError => e
+            Logger.error("Failed to terminate process #{pid}: #{e.message}")
+          end
+        end
+      rescue StandardError => e
+        Logger.error("Failed to cleanup agents: #{e.message}")
+      end
+    end
+  end
+end

data/lib/enhance_swarm/retry_handler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module EnhanceSwarm
+  class RetryHandler
+    class RetryError < StandardError; end
+
+    def self.with_retry(max_retries: 3, base_delay: 1, max_delay: 30, &block)
+      retries = 0
+      
+      begin
+        yield
+      rescue StandardError => e
+        retries += 1
+        
+        if retries <= max_retries && retryable_error?(e)
+          delay = [base_delay * (2 ** (retries - 1)), max_delay].min
+          puts "Attempt #{retries} failed: #{e.message}. Retrying in #{delay}s...".colorize(:yellow)
+          sleep(delay)
+          retry
+        end
+        
+        raise RetryError.new("Operation failed after #{max_retries} retries: #{e.message}")
+      end
+    end
+
+    def self.retryable_error?(error)
+      case error
+      when CommandExecutor::CommandError
+        # Retry on timeout or command not found, but not on validation errors
+        error.message.include?('timed out') || error.message.include?('not found')
+      when Errno::ENOENT, Errno::ECONNREFUSED, Errno::ETIMEDOUT
+        true
+      when IOError, SystemCallError
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/enhance_swarm/session_manager.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'securerandom'
+require_relative 'logger'
+
+module EnhanceSwarm
+  class SessionManager
+    SESSION_DIR = '.enhance_swarm'
+    SESSION_FILE = 'session.json'
+
+    def initialize
+      @session_path = File.join(Dir.pwd, SESSION_DIR, SESSION_FILE)
+      ensure_session_directory
+    end
+
+    def create_session(task_description = nil)
+      session_data = {
+        session_id: generate_session_id,
+        start_time: Time.now.iso8601,
+        task_description: task_description,
+        agents: [],
+        status: 'active'
+      }
+      
+      write_session(session_data)
+      Logger.info("Created new session: #{session_data[:session_id]}")
+      session_data
+    end
+
+    def add_agent(role, pid, worktree_path, task = nil)
+      session = read_session
+      return false unless session
+
+      agent_data = {
+        role: role,
+        pid: pid,
+        worktree_path: worktree_path,
+        task: task,
+        start_time: Time.now.iso8601,
+        status: 'running'
+      }
+
+      session[:agents] << agent_data
+      write_session(session)
+      Logger.info("Added agent to session: #{role} (PID: #{pid})")
+      true
+    end
+
+    def update_agent_status(pid, status, completion_time = nil)
+      session = read_session
+      return false unless session
+
+      agent = session[:agents].find { |a| a[:pid] == pid }
+      return false unless agent
+
+      agent[:status] = status
+      agent[:completion_time] = completion_time if completion_time
+
+      write_session(session)
+      Logger.info("Updated agent status: PID #{pid} -> #{status}")
+      true
+    end
+
+    def remove_agent(pid)
+      session = read_session
+      return false unless session
+
+      initial_count = session[:agents].length
+      session[:agents].reject! { |a| a[:pid] == pid }
+      
+      if session[:agents].length < initial_count
+        write_session(session)
+        Logger.info("Removed agent from session: PID #{pid}")
+        true
+      else
+        false
+      end
+    end
+
+    def get_active_agents
+      session = read_session
+      return [] unless session
+
+      session[:agents].select { |a| a[:status] == 'running' }
+    end
+
+    def get_all_agents
+      session = read_session
+      return [] unless session
+
+      session[:agents] || []
+    end
+
+    def session_exists?
+      File.exist?(@session_path)
+    end
+
+    def read_session
+      return nil unless session_exists?
+
+      begin
+        content = File.read(@session_path)
+        JSON.parse(content, symbolize_names: true)
+      rescue JSON::ParserError, StandardError => e
+        Logger.error("Failed to read session file: #{e.message}")
+        nil
+      end
+    end
+
+    def session_status
+      session = read_session
+      return { exists: false } unless session
+
+      active_agents = get_active_agents
+      all_agents = get_all_agents
+      
+      {
+        exists: true,
+        session_id: session[:session_id],
+        start_time: session[:start_time],
+        task_description: session[:task_description],
+        status: session[:status],
+        total_agents: all_agents.length,
+        active_agents: active_agents.length,
+        completed_agents: all_agents.count { |a| a[:status] == 'completed' },
+        failed_agents: all_agents.count { |a| a[:status] == 'failed' },
+        agents: all_agents
+      }
+    end
+
+    def close_session
+      session = read_session
+      return false unless session
+
+      session[:status] = 'completed'
+      session[:end_time] = Time.now.iso8601
+      write_session(session)
+      Logger.info("Closed session: #{session[:session_id]}")
+      true
+    end
+
+    def cleanup_session
+      return false unless session_exists?
+
+      # Archive the session before removing
+      if archive_session
+        File.delete(@session_path)
+        Logger.info("Cleaned up session file")
+        true
+      else
+        false
+      end
+    end
+
+    def check_agent_processes
+      session = read_session
+      return [] unless session
+
+      updated_agents = []
+      session_changed = false
+
+      session[:agents].each do |agent|
+        next unless agent[:status] == 'running'
+
+        # Check if process is still running
+        if process_running?(agent[:pid])
+          updated_agents << agent
+        else
+          # Process is no longer running, update status
+          agent[:status] = 'stopped'
+          agent[:completion_time] = Time.now.iso8601
+          session_changed = true
+          Logger.info("Agent process stopped: #{agent[:role]} (PID: #{agent[:pid]})")
+        end
+      end
+
+      write_session(session) if session_changed
+      updated_agents
+    end
+
+    private
+
+    def ensure_session_directory
+      session_dir = File.dirname(@session_path)
+      FileUtils.mkdir_p(session_dir) unless Dir.exist?(session_dir)
+    end
+
+    def write_session(session_data)
+      begin
+        File.write(@session_path, JSON.pretty_generate(session_data))
+        true
+      rescue StandardError => e
+        Logger.error("Failed to write session file: #{e.message}")
+        false
+      end
+    end
+
+    def generate_session_id
+      Time.now.to_i.to_s + '_' + SecureRandom.hex(4)
+    end
+
+    def archive_session
+      return true unless session_exists?
+
+      begin
+        session = read_session
+        return false unless session
+
+        # Create archives directory
+        archive_dir = File.join(Dir.pwd, SESSION_DIR, 'archives')
+        FileUtils.mkdir_p(archive_dir)
+
+        # Create archive filename with session ID and timestamp
+        archive_name = "session_#{session[:session_id]}_#{Time.now.strftime('%Y%m%d_%H%M%S')}.json"
+        archive_path = File.join(archive_dir, archive_name)
+
+        FileUtils.cp(@session_path, archive_path)
+        Logger.info("Archived session to: #{archive_path}")
+        true
+      rescue StandardError => e
+        Logger.error("Failed to archive session: #{e.message}")
+        false
+      end
+    end
+
+    def process_running?(pid)
+      begin
+        # Use Process.kill(0, pid) to check if process exists
+        # This doesn't actually kill the process, just checks if it's running
+        Process.kill(0, pid.to_i)
+        true
+      rescue Errno::ESRCH
+        # Process doesn't exist
+        false
+      rescue Errno::EPERM
+        # Process exists but we don't have permission to signal it
+        # This means it's running but owned by another user
+        true
+      rescue StandardError
+        # Any other error, assume process is not running
+        false
+      end
+    end
+  end
+end

data/lib/enhance_swarm/signal_handler.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+require_relative 'cleanup_manager'
+
+module EnhanceSwarm
+  class SignalHandler
+    def self.setup
+      @shutdown_requested = false
+      @active_operations = {}
+      
+      # Handle graceful shutdown signals
+      Signal.trap('INT') { handle_shutdown('SIGINT') }
+      Signal.trap('TERM') { handle_shutdown('SIGTERM') }
+      
+      # Handle info signal for status
+      if Signal.list.key?('USR1')
+        Signal.trap('USR1') { handle_status_request }
+      end
+    end
+
+    def self.handle_shutdown(signal)
+      return if @shutdown_requested
+      
+      @shutdown_requested = true
+      Logger.info("Received #{signal}, initiating graceful shutdown...")
+      
+      begin
+        # Stop accepting new operations
+        puts "\n🛑 Graceful shutdown initiated...".colorize(:yellow)
+        
+        # Clean up any active operations
+        cleanup_active_operations
+        
+        # Perform final cleanup
+        CleanupManager.cleanup_all_swarm_resources
+        
+        Logger.info("Graceful shutdown completed")
+        puts "✅ Shutdown complete".colorize(:green)
+        
+        exit(0)
+      rescue StandardError => e
+        Logger.error("Error during shutdown: #{e.message}")
+        puts "❌ Error during shutdown: #{e.message}".colorize(:red)
+        exit(1)
+      end
+    end
+
+    def self.handle_status_request
+      Logger.info("Status request received via USR1")
+      
+      status = {
+        active_operations: @active_operations.size,
+        shutdown_requested: @shutdown_requested,
+        timestamp: Time.now.iso8601
+      }
+      
+      puts JSON.pretty_generate(status)
+    end
+
+    def self.register_operation(operation_id, details = {})
+      @active_operations ||= {}
+      @active_operations[operation_id] = {
+        started_at: Time.now,
+        details: details
+      }
+    end
+
+    def self.unregister_operation(operation_id)
+      @active_operations&.delete(operation_id)
+    end
+
+    def self.shutdown_requested?
+      @shutdown_requested
+    end
+
+    private
+
+    def self.cleanup_active_operations
+      return unless @active_operations&.any?
+      
+      Logger.info("Cleaning up #{@active_operations.size} active operations")
+      
+      @active_operations.each do |operation_id, details|
+        begin
+          CleanupManager.cleanup_failed_operation(operation_id, details[:details])
+        rescue StandardError => e
+          Logger.error("Failed to cleanup operation #{operation_id}: #{e.message}")
+        end
+      end
+      
+      @active_operations.clear
+    end
+  end
+end