enhance_swarm 1.0.0

data/lib/enhance_swarm/command_executor.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require 'timeout'
+
+module EnhanceSwarm
+  class CommandExecutor
+    class CommandError < StandardError
+      attr_reader :exit_status, :stderr
+
+      def initialize(message, exit_status: nil, stderr: nil)
+        super(message)
+        @exit_status = exit_status
+        @stderr = stderr
+      end
+    end
+
+    def self.execute(command, *args, timeout: 30, input: nil)
+      # Sanitize command and arguments
+      safe_command = sanitize_command(command)
+      safe_args = args.map { |arg| sanitize_argument(arg) }
+
+      begin
+        Timeout.timeout(timeout) do
+          stdout, stderr, status = Open3.capture3(safe_command, *safe_args,
+                                                  stdin_data: input)
+
+          unless status.success?
+            raise CommandError.new(
+              "Command failed: #{safe_command} #{safe_args.join(' ')}",
+              exit_status: status.exitstatus,
+              stderr: stderr
+            )
+          end
+
+          stdout.strip
+        end
+      rescue Timeout::Error
+        raise CommandError.new("Command timed out after #{timeout} seconds")
+      rescue Errno::ENOENT
+        raise CommandError.new("Command not found: #{safe_command}")
+      end
+    end
+
+    def self.execute_async(command, *args)
+      safe_command = sanitize_command(command)
+      safe_args = args.map { |arg| sanitize_argument(arg) }
+
+      begin
+        pid = Process.spawn(safe_command, *safe_args)
+        Process.detach(pid)
+        pid
+      rescue Errno::ENOENT
+        raise CommandError.new("Command not found: #{safe_command}")
+      end
+    end
+
+    def self.command_available?(command)
+      execute('which', command, timeout: 5)
+      true
+    rescue CommandError
+      false
+    end
+
+    def self.sanitize_command(command)
+      # Only allow alphanumeric, dash, underscore, and slash
+      raise ArgumentError, "Invalid command: #{command}" unless command.match?(%r{\A[a-zA-Z0-9_\-/]+\z})
+
+      command
+    end
+
+    def self.sanitize_argument(arg)
+      # Convert to string and escape shell metacharacters
+      Shellwords.escape(arg.to_s)
+    end
+  end
+end

data/lib/enhance_swarm/configuration.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require 'psych'
+require_relative 'project_analyzer'
+
+module EnhanceSwarm
+  class Configuration
+    attr_accessor :project_name, :project_description, :technology_stack,
+                  :test_command, :task_command, :task_move_command,
+                  :code_standards, :important_notes,
+                  :max_concurrent_agents, :monitor_interval,
+                  :monitor_timeout, :worktree_enabled,
+                  :mcp_tools, :gemini_enabled, :desktop_commander_enabled,
+                  :max_memory_mb, :max_disk_mb
+
+    def initialize
+      # Apply smart defaults from project analysis if no config exists
+      if config_file_exists?
+        apply_hardcoded_defaults
+        load_from_file
+      else
+        apply_smart_defaults
+      end
+    end
+
+    def to_h
+      {
+        project: {
+          name: @project_name,
+          description: @project_description,
+          technology_stack: @technology_stack
+        },
+        commands: {
+          test: @test_command,
+          task: @task_command,
+          task_move: @task_move_command
+        },
+        orchestration: {
+          max_concurrent_agents: @max_concurrent_agents,
+          monitor_interval: @monitor_interval,
+          monitor_timeout: @monitor_timeout,
+          worktree_enabled: @worktree_enabled
+        },
+        mcp: {
+          tools: @mcp_tools,
+          gemini_enabled: @gemini_enabled,
+          desktop_commander_enabled: @desktop_commander_enabled
+        },
+        standards: {
+          code: @code_standards,
+          notes: @important_notes
+        }
+      }
+    end
+
+    def save!
+      File.write(config_file_path, Psych.dump(to_h))
+    end
+
+    private
+
+    def apply_hardcoded_defaults
+      # Project defaults
+      @project_name = 'Project'
+      @project_description = 'A project managed by EnhanceSwarm'
+      @technology_stack = 'Ruby on Rails'
+
+      # Commands
+      @test_command = 'bundle exec rails test'
+      @task_command = 'bundle exec swarm-tasks'
+      @task_move_command = 'bundle exec swarm-tasks move'
+
+      # Standards
+      @code_standards = default_code_standards
+      @important_notes = []
+
+      # Orchestration settings
+      @max_concurrent_agents = 4
+      @monitor_interval = 30
+      @monitor_timeout = 120 # 2 minutes max per monitoring session
+      @worktree_enabled = true
+
+      # Resource limits
+      @max_memory_mb = 2048  # 2GB max memory for all agents
+      @max_disk_mb = 1024    # 1GB max disk usage
+
+      # MCP settings
+      @mcp_tools = {
+        context7: true,
+        sequential: true,
+        magic_ui: true,
+        puppeteer: true
+      }
+      @gemini_enabled = true
+      @desktop_commander_enabled = true
+    end
+
+    def apply_smart_defaults
+      Logger.info("No configuration file found, applying smart defaults based on project analysis")
+      
+      # Analyze the current project
+      analyzer = ProjectAnalyzer.new
+      analyzer.analyze
+      smart_defaults = analyzer.generate_smart_defaults
+
+      # Apply smart defaults with fallbacks
+      @project_name = smart_defaults[:project_name] || File.basename(Dir.pwd)
+      @project_description = smart_defaults[:project_description] || 'A project managed by EnhanceSwarm'
+      @technology_stack = smart_defaults[:technology_stack]&.join(', ') || 'Multiple Technologies'
+
+      # Smart command detection
+      @test_command = smart_defaults[:test_command] || detect_test_command_fallback
+      @task_command = 'bundle exec swarm-tasks'
+      @task_move_command = 'bundle exec swarm-tasks move'
+
+      # Code standards based on project type
+      @code_standards = generate_smart_code_standards(analyzer.analysis_results[:project_type])
+      @important_notes = generate_smart_notes(analyzer.analysis_results)
+
+      # Orchestration settings based on project size
+      @max_concurrent_agents = smart_defaults[:max_concurrent_agents] || 3
+      @monitor_interval = 30
+      @monitor_timeout = 120
+      @worktree_enabled = true
+
+      # MCP settings - enable all by default for smart detection
+      @mcp_tools = {
+        context7: true,
+        sequential: true,
+        magic_ui: analyzer.analysis_results[:frontend_framework] ? true : false,
+        puppeteer: analyzer.analysis_results[:testing_framework]&.any? { |f| f.include?('Cypress') || f.include?('Playwright') } || false
+      }
+      @gemini_enabled = true
+      @desktop_commander_enabled = smart_defaults[:has_documentation] || false
+
+      Logger.info("Applied smart defaults for #{@project_name} (#{@technology_stack})")
+    end
+
+    def detect_test_command_fallback
+      return 'bundle exec rspec' if File.exist?('spec')
+      return 'bundle exec rails test' if File.exist?('test')
+      return 'npm test' if File.exist?('package.json')
+      return 'pytest' if File.exist?('pytest.ini') || File.exist?('conftest.py')
+      
+      'echo "No test command configured"'
+    end
+
+    def generate_smart_code_standards(project_type)
+      base_standards = [
+        'Follow framework conventions',
+        'Write tests for all new features',
+        'Use clear, descriptive naming'
+      ]
+
+      case project_type
+      when 'rails'
+        base_standards + [
+          'Use service objects for business logic',
+          'Keep controllers thin',
+          'Use strong validations in models'
+        ]
+      when 'react', 'vue', 'angular', 'nextjs'
+        base_standards + [
+          'Use functional components with hooks',
+          'Implement proper state management',
+          'Optimize for performance and accessibility'
+        ]
+      when 'django', 'flask'
+        base_standards + [
+          'Follow MVC patterns',
+          'Use proper authentication and authorization',
+          'Implement comprehensive API documentation'
+        ]
+      else
+        base_standards + [
+          'Maintain consistent code style',
+          'Document complex logic',
+          'Use version control best practices'
+        ]
+      end
+    end
+
+    def generate_smart_notes(analysis_results)
+      notes = []
+
+      if analysis_results[:documentation]&.dig(:has_docs)
+        notes << "Project has documentation in #{analysis_results[:documentation][:primary_path]} - consider this context for changes"
+      end
+
+      if analysis_results[:testing_framework]&.any?
+        frameworks = analysis_results[:testing_framework].join(', ')
+        notes << "Testing framework(s) detected: #{frameworks} - ensure new features include tests"
+      end
+
+      if analysis_results[:deployment]&.any?
+        deployments = analysis_results[:deployment].join(', ')
+        notes << "Deployment configurations found: #{deployments} - consider deployment impact for changes"
+      end
+
+      if analysis_results[:database]&.any?
+        databases = analysis_results[:database].join(', ')
+        notes << "Database(s) in use: #{databases} - consider data migration needs"
+      end
+
+      notes
+    end
+
+    def config_file_path
+      File.join(EnhanceSwarm.root, '.enhance_swarm.yml')
+    end
+
+    def config_file_exists?
+      File.exist?(config_file_path)
+    end
+
+    def load_from_file
+      config = Psych.safe_load(File.read(config_file_path), permitted_classes: [Symbol])
+
+      # Project settings with validation
+      @project_name = validate_string(config.dig('project', 'name')) || @project_name
+      @project_description = validate_string(config.dig('project', 'description')) || @project_description
+      @technology_stack = validate_string(config.dig('project', 'technology_stack')) || @technology_stack
+
+      # Commands with validation
+      @test_command = validate_command(config.dig('commands', 'test')) || @test_command
+      @task_command = validate_command(config.dig('commands', 'task')) || @task_command
+      @task_move_command = validate_command(config.dig('commands', 'task_move')) || @task_move_command
+
+      # Orchestration with validation
+      @max_concurrent_agents = validate_positive_integer(config.dig('orchestration',
+                                                                    'max_concurrent_agents')) || @max_concurrent_agents
+      @monitor_interval = validate_positive_integer(config.dig('orchestration',
+                                                               'monitor_interval')) || @monitor_interval
+      @monitor_timeout = validate_positive_integer(config.dig('orchestration', 'monitor_timeout')) || @monitor_timeout
+      @worktree_enabled = config.dig('orchestration', 'worktree_enabled') != false
+
+      # MCP
+      @mcp_tools = validate_hash(config.dig('mcp', 'tools')) || @mcp_tools
+      @gemini_enabled = config.dig('mcp', 'gemini_enabled') != false
+      @desktop_commander_enabled = config.dig('mcp', 'desktop_commander_enabled') != false
+
+      # Standards
+      @code_standards = validate_array(config.dig('standards', 'code')) || @code_standards
+      @important_notes = validate_array(config.dig('standards', 'notes')) || @important_notes
+    rescue Psych::SyntaxError => e
+      puts "Configuration file has invalid YAML syntax: #{e.message}"
+      # Use defaults
+    rescue StandardError => e
+      puts "Error loading configuration: #{e.message}"
+      # Use defaults
+    end
+
+    def default_code_standards
+      [
+        'Follow framework conventions',
+        'Use service objects for business logic',
+        'Keep controllers thin',
+        'Write tests for all new features',
+        'Use strong validations in models'
+      ]
+    end
+
+    # Validation methods
+    def validate_string(value)
+      return nil unless value.is_a?(String)
+
+      # Remove dangerous characters
+      sanitized = value.gsub(/[`$\\;|&]/, '').strip
+      sanitized.empty? ? nil : sanitized
+    end
+
+    def validate_command(value)
+      return nil unless value.is_a?(String)
+
+      # Only allow safe command characters
+      sanitized = value.gsub(/[;|&`$\\]/, '').strip
+      return nil if sanitized.empty?
+
+# Check for common dangerous patterns but allow 'exec' in normal contexts
+      dangerous_patterns = [/\brm\s+-rf/, /\|\s*sh\b/, /\beval\s*\(/, /\bexec\s*\(/]
+      dangerous_patterns.each do |pattern|
+        return nil if sanitized.match?(pattern)
+      end
+
+      sanitized
+    end
+
+    def validate_positive_integer(value)
+      return nil unless value.is_a?(Integer) || (value.is_a?(String) && value.match?(/\A\d+\z/))
+
+      int_value = value.to_i
+      int_value.positive? ? int_value : nil
+    end
+
+    def validate_array(value)
+      return nil unless value.is_a?(Array)
+
+      # Validate each element as a string
+      validated = value.map { |item| validate_string(item) }.compact
+      validated.empty? ? nil : validated
+    end
+
+    def validate_hash(value)
+      return nil unless value.is_a?(Hash)
+
+      # Ensure all keys are strings or symbols and values are safe
+      validated = {}
+      value.each do |k, v|
+        next unless k.is_a?(String) || k.is_a?(Symbol)
+
+        validated[k] = case v
+                       when String
+                         validate_string(v)
+                       when TrueClass, FalseClass
+                         v
+                       when Integer
+                         validate_positive_integer(v)
+                       end
+      end
+
+      validated.empty? ? nil : validated
+    end
+  end
+end

data/lib/enhance_swarm/control_agent.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tempfile'
+
+module EnhanceSwarm
+  class ControlAgent
+    attr_reader :task, :config, :status, :worker_agents, :start_time
+
+    def initialize(task_description, config = nil)
+      @task = task_description
+      @config = config || EnhanceSwarm.configuration
+      @status = 'initializing'
+      @worker_agents = {}
+      @start_time = Time.now
+      @communication_file = create_communication_file
+      @control_process = nil
+    end
+
+    def start_coordination
+      Logger.info("Starting Control Agent for task: #{@task}")
+      @status = 'starting'
+      
+      # Spawn the Control Agent as a Claude process
+      spawn_control_agent
+      
+      # Monitor and coordinate
+      coordinate_agents
+    end
+
+    def stop_coordination
+      Logger.info("Stopping Control Agent coordination")
+      @status = 'stopping'
+      
+      # Terminate control agent process
+      if @control_process
+        begin
+          Process.kill('TERM', @control_process)
+          Process.wait(@control_process)
+        rescue Errno::ESRCH, Errno::ECHILD
+          # Process already terminated
+        end
+      end
+      
+      # Cleanup
+      cleanup_resources
+    end
+
+    def current_status
+      return default_status unless File.exist?(@communication_file)
+      
+      begin
+        content = File.read(@communication_file)
+        return default_status if content.strip.empty?
+        
+        # Parse the latest status update from Control Agent
+        lines = content.split("\n").reject(&:empty?)
+        latest_status = lines.last
+        
+        JSON.parse(latest_status)
+      rescue JSON::ParserError, StandardError => e
+        Logger.warn("Failed to parse control agent status: #{e.message}")
+        default_status
+      end
+    end
+
+    def worker_agent_summary
+      status = current_status
+      {
+        total: status['active_agents'].length + status['completed_agents'].length,
+        active: status['active_agents'].length,
+        completed: status['completed_agents'].length,
+        progress: status['progress_percentage'] || 0,
+        phase: status['phase'] || 'unknown',
+        estimated_completion: status['estimated_completion']
+      }
+    end
+
+    private
+
+    def spawn_control_agent
+      prompt = build_control_agent_prompt
+      
+      # Create a temporary prompt file
+      prompt_file = Tempfile.new(['control_prompt', '.txt'])
+      prompt_file.write(prompt)
+      prompt_file.close
+      
+      begin
+        # Spawn Control Agent using claude command
+        @control_process = RetryHandler.with_retry(max_retries: 2) do
+          CommandExecutor.execute_async(
+            'claude', 
+            '--role=control',
+            '--file', prompt_file.path,
+            '--output', @communication_file,
+            '--continuous'
+          )
+        end
+        
+        Logger.info("Control Agent spawned with PID: #{@control_process}")
+        @status = 'coordinating'
+        
+      rescue RetryHandler::RetryError, CommandExecutor::CommandError => e
+        Logger.error("Failed to spawn Control Agent: #{e.message}")
+        @status = 'failed'
+        raise
+      ensure
+        prompt_file.unlink
+      end
+    end
+
+    def coordinate_agents
+      coordination_thread = Thread.new do
+        while @status == 'coordinating'
+          begin
+            # Read latest status from Control Agent
+            agent_status = current_status
+            
+            # Update our internal state
+            update_worker_agents(agent_status)
+            
+            # Check if coordination is complete
+            if agent_status['status'] == 'completed'
+              @status = 'completed'
+              break
+            elsif agent_status['status'] == 'failed'
+              @status = 'failed'
+              break
+            end
+            
+            sleep(5) # Check every 5 seconds
+            
+          rescue StandardError => e
+            Logger.error("Control Agent coordination error: #{e.message}")
+            sleep(10) # Back off on errors
+          end
+        end
+        
+        Logger.info("Control Agent coordination finished with status: #{@status}")
+      end
+      
+      coordination_thread
+    end
+
+    def update_worker_agents(agent_status)
+      # Track active agents
+      agent_status['active_agents']&.each do |agent_id|
+        unless @worker_agents[agent_id]
+          @worker_agents[agent_id] = {
+            id: agent_id,
+            status: 'active',
+            start_time: Time.now
+          }
+        end
+      end
+      
+      # Track completed agents
+      agent_status['completed_agents']&.each do |agent_id|
+        if @worker_agents[agent_id]
+          @worker_agents[agent_id][:status] = 'completed'
+          @worker_agents[agent_id][:completion_time] = Time.now
+        end
+      end
+    end
+
+    def build_control_agent_prompt
+      <<~PROMPT
+        AUTONOMOUS CONTROL AGENT - MULTI-AGENT COORDINATION
+
+        TASK: #{@task}
+
+        YOUR ROLE: You are a Control Agent responsible for coordinating multiple worker agents to complete this task efficiently. You have full autonomous authority to make decisions and spawn agents.
+
+        CAPABILITIES:
+        1. Spawn worker agents using: claude-swarm start --role=<role> -p "<specific_task>"
+        2. Monitor progress via git commands: git status, git log, git diff
+        3. Analyze file changes and commits to understand progress
+        4. Make handoff decisions based on dependencies and completion status
+        5. Coordinate timing to prevent conflicts
+
+        WORKER AGENT ROLES:
+        - backend: Models, APIs, database, business logic, migrations, services
+        - frontend: Controllers, views, JavaScript, CSS, user interface, forms
+        - ux: User experience design, templates, layouts, styling, wireframes  
+        - qa: Testing, specs, edge cases, quality assurance, validation
+
+        COORDINATION STRATEGY:
+        1. Analyze the task to determine which roles are needed
+        2. Identify dependencies (typically: backend → frontend → qa)
+        3. Spawn agents in dependency order
+        4. Monitor their progress via git commits and file changes
+        5. Signal next agent when prerequisites are met
+        6. Handle conflicts and coordination issues
+
+        COMMUNICATION PROTOCOL:
+        You MUST output status updates in JSON format to #{@communication_file}
+        Update every 30 seconds with current status.
+
+        Required JSON format:
+        {
+          "status": "coordinating|completed|failed",
+          "phase": "analysis|backend_implementation|frontend_integration|qa_validation|completion",
+          "active_agents": ["agent-id-1", "agent-id-2"],
+          "completed_agents": ["agent-id-3"],
+          "failed_agents": [],
+          "progress_percentage": 45,
+          "estimated_completion": "2025-06-28T20:30:00Z",
+          "message": "Backend agent completed auth model, starting frontend integration",
+          "next_actions": ["spawn_frontend_agent", "monitor_integration_conflicts"],
+          "dependencies_met": ["backend_models_complete"],
+          "blocking_issues": []
+        }
+
+        CRITICAL INSTRUCTIONS:
+        1. You have FULL PERMISSION to execute commands and spawn agents
+        2. Work directory: #{Dir.pwd}
+        3. Start immediately by analyzing the task and creating an execution plan
+        4. Spawn the first agent(s) based on dependencies
+        5. Continuously monitor and coordinate until task completion
+        6. Handle errors gracefully and retry failed operations
+        7. Ensure all agents complete successfully before marking task complete
+
+        PROJECT CONTEXT:
+        - Technology stack: #{Array(@config.technology_stack).join(', ')}
+        - Test command: #{@config.test_command}
+        - Project type: #{@config.project_name}
+
+        BEGIN COORDINATION NOW.
+      PROMPT
+    end
+
+    def create_communication_file
+      # Create a temporary file for Control Agent communication
+      temp_file = Tempfile.new(['control_agent_status', '.json'])
+      temp_file.close
+      temp_file.path
+    end
+
+    def default_status
+      {
+        'status' => @status,
+        'phase' => 'initializing',
+        'active_agents' => [],
+        'completed_agents' => [],
+        'failed_agents' => [],
+        'progress_percentage' => 0,
+        'message' => 'Control Agent initializing...',
+        'estimated_completion' => nil
+      }
+    end
+
+    def cleanup_resources
+      # Clean up communication file
+      File.unlink(@communication_file) if File.exist?(@communication_file)
+    rescue StandardError => e
+      Logger.warn("Failed to cleanup Control Agent resources: #{e.message}")
+    end
+
+    # Class methods for easy usage
+    def self.coordinate_task(task_description, config: nil)
+      control_agent = new(task_description, config)
+      
+      begin
+        coordination_thread = control_agent.start_coordination
+        
+        # Return control agent for monitoring
+        yield control_agent if block_given?
+        
+        # Wait for coordination to complete
+        coordination_thread.join if coordination_thread
+        
+        control_agent.current_status
+      ensure
+        control_agent.stop_coordination
+      end
+    end
+
+    # Enhanced progress tracking integration
+    def track_progress_with_streamer(streamer = nil)
+      return unless streamer
+      
+      Thread.new do
+        while @status == 'coordinating'
+          status = current_status
+          
+          # Update progress tracker
+          progress = status['progress_percentage'] || 0
+          message = status['message'] || 'Coordinating agents...'
+          
+          streamer.set_progress(progress,
+                              message: message,
+                              operation: 'control_coordination',
+                              details: {
+                                phase: status['phase'],
+                                active_agents: status['active_agents']&.length || 0,
+                                completed_agents: status['completed_agents']&.length || 0
+                              })
+          
+          break if %w[completed failed].include?(status['status'])
+          
+          sleep(2)
+        end
+      end
+    end
+  end
+end