rcrewai 0.1.0

data/lib/rcrewai/async_executor.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'logger'
+
+module RCrewAI
+  class AsyncExecutor
+    attr_reader :thread_pool, :logger, :max_concurrency
+
+    def initialize(**options)
+      @max_concurrency = options.fetch(:max_concurrency, Concurrent.processor_count)
+      @timeout = options.fetch(:timeout, 300) # 5 minutes default
+      @logger = Logger.new($stdout)
+      @logger.level = options.fetch(:verbose, false) ? Logger::DEBUG : Logger::INFO
+      
+      # Create thread pool for task execution
+      @thread_pool = Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: @max_concurrency,
+        max_queue: @max_concurrency * 2,
+        fallback_policy: :caller_runs
+      )
+      
+      @futures = {}
+      @task_dependencies = {}
+      @completed_tasks = Concurrent::Set.new
+      @failed_tasks = Concurrent::Set.new
+    end
+
+    def execute_tasks_async(tasks, dependency_graph = {})
+      @logger.info "Starting async execution of #{tasks.length} tasks with max #{@max_concurrency} concurrent threads"
+      
+      @task_dependencies = dependency_graph
+      execution_phases = organize_tasks_by_dependencies(tasks)
+      
+      start_time = Time.now
+      results = []
+      
+      execution_phases.each_with_index do |phase_tasks, phase_index|
+        @logger.info "Executing phase #{phase_index + 1}: #{phase_tasks.length} tasks"
+        
+        phase_results = execute_phase_concurrently(phase_tasks, phase_index + 1)
+        results.concat(phase_results)
+        
+        # Check if we should continue
+        failed_in_phase = phase_results.count { |r| r[:status] == :failed }
+        if failed_in_phase > 0 && should_abort_after_failures?(failed_in_phase, phase_tasks.length)
+          @logger.error "Aborting execution due to #{failed_in_phase} failures in phase #{phase_index + 1}"
+          break
+        end
+      end
+      
+      total_time = Time.now - start_time
+      @logger.info "Async execution completed in #{total_time.round(2)}s"
+      
+      format_async_results(results, total_time)
+    end
+
+    def execute_single_task_async(task)
+      future = Concurrent::Future.execute(executor: @thread_pool) do
+        execute_task_with_monitoring(task)
+      end
+      
+      @futures[task] = future
+      future
+    end
+
+    def wait_for_completion(futures, timeout = nil)
+      timeout ||= @timeout
+      
+      results = []
+      futures.each do |task, future|
+        begin
+          result = future.value(timeout)
+          results << { task: task, result: result, status: :completed }
+        rescue Concurrent::TimeoutError
+          @logger.error "Task #{task.name} timed out after #{timeout}s"
+          results << { task: task, result: "Task timed out", status: :timeout }
+        rescue => e
+          @logger.error "Task #{task.name} failed: #{e.message}"
+          results << { task: task, result: e.message, status: :failed }
+        end
+      end
+      
+      results
+    end
+
+    def shutdown
+      @logger.info "Shutting down async executor..."
+      @thread_pool.shutdown
+      unless @thread_pool.wait_for_termination(30)
+        @logger.warn "Thread pool did not shut down gracefully, forcing shutdown"
+        @thread_pool.kill
+      end
+    end
+
+    def stats
+      {
+        max_concurrency: @max_concurrency,
+        active_threads: @thread_pool.length,
+        queue_length: @thread_pool.queue_length,
+        completed_task_count: @completed_tasks.size,
+        failed_task_count: @failed_tasks.size,
+        pool_shutdown: @thread_pool.shutdown?
+      }
+    end
+
+    private
+
+    def organize_tasks_by_dependencies(tasks)
+      phases = []
+      remaining_tasks = tasks.dup
+      completed_task_names = Set.new
+
+      while remaining_tasks.any?
+        # Find tasks with no unmet dependencies
+        ready_tasks = remaining_tasks.select do |task|
+          dependencies = @task_dependencies[task] || task.context || []
+          dependencies.all? { |dep| completed_task_names.include?(dep.name) }
+        end
+
+        if ready_tasks.empty?
+          # Handle circular dependencies by running remaining tasks in parallel
+          @logger.warn "Circular dependency detected, executing remaining #{remaining_tasks.length} tasks in parallel"
+          phases << remaining_tasks
+          break
+        end
+
+        phases << ready_tasks
+        remaining_tasks -= ready_tasks
+        ready_tasks.each { |task| completed_task_names.add(task.name) }
+      end
+
+      phases
+    end
+
+    def execute_phase_concurrently(phase_tasks, phase_number)
+      @logger.debug "Phase #{phase_number}: Launching #{phase_tasks.length} concurrent tasks"
+      
+      # Launch all tasks in this phase concurrently
+      phase_futures = {}
+      phase_tasks.each do |task|
+        future = execute_single_task_async(task)
+        phase_futures[task] = future
+      end
+
+      # Wait for all tasks in this phase to complete
+      phase_results = wait_for_completion(phase_futures)
+      
+      # Update tracking sets
+      phase_results.each do |result|
+        case result[:status]
+        when :completed
+          @completed_tasks.add(result[:task])
+        when :failed, :timeout
+          @failed_tasks.add(result[:task])
+        end
+      end
+      
+      @logger.info "Phase #{phase_number} completed: #{phase_results.count { |r| r[:status] == :completed }}/#{phase_tasks.length} successful"
+      
+      phase_results.map { |r| r.merge(phase: phase_number) }
+    end
+
+    def execute_task_with_monitoring(task)
+      thread_id = Thread.current.object_id
+      @logger.debug "Task #{task.name} starting on thread #{thread_id}"
+      
+      start_time = Time.now
+      
+      begin
+        # Add async context to task
+        task.instance_variable_set(:@async_execution, true)
+        task.instance_variable_set(:@thread_id, thread_id)
+        
+        # Execute the task
+        result = task.execute
+        
+        execution_time = Time.now - start_time
+        @logger.debug "Task #{task.name} completed in #{execution_time.round(2)}s on thread #{thread_id}"
+        
+        result
+      rescue => e
+        execution_time = Time.now - start_time
+        @logger.error "Task #{task.name} failed after #{execution_time.round(2)}s on thread #{thread_id}: #{e.message}"
+        raise e
+      end
+    end
+
+    def should_abort_after_failures?(failed_count, total_count)
+      failure_rate = failed_count.to_f / total_count
+      
+      # Abort if more than 50% of tasks in a phase fail
+      failure_rate > 0.5
+    end
+
+    def format_async_results(results, total_time)
+      completed = results.count { |r| r[:status] == :completed }
+      failed = results.count { |r| r[:status] == :failed }
+      timed_out = results.count { |r| r[:status] == :timeout }
+      
+      {
+        execution_mode: :async,
+        total_time: total_time,
+        max_concurrency: @max_concurrency,
+        total_tasks: results.length,
+        completed_tasks: completed,
+        failed_tasks: failed,
+        timed_out_tasks: timed_out,
+        success_rate: (completed.to_f / results.length * 100).round(1),
+        results: results,
+        thread_pool_stats: {
+          max_threads: @thread_pool.max_length,
+          current_threads: @thread_pool.length,
+          largest_length: @thread_pool.largest_length
+        }
+      }
+    end
+  end
+
+  # Extensions to existing classes for async support
+  module AsyncExtensions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def execute_async(tasks, **options)
+        executor = AsyncExecutor.new(**options)
+        
+        begin
+          results = executor.execute_tasks_async(tasks)
+          results
+        ensure
+          executor.shutdown
+        end
+      end
+    end
+
+    def async_execution?
+      @async_execution || false
+    end
+
+    def thread_id
+      @thread_id
+    end
+  end
+end

data/lib/rcrewai/cli.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RCrewAI
+  class CLI < Thor
+    desc "new CREW_NAME", "Create a new AI crew"
+    def new(crew_name)
+      puts "Creating new crew: #{crew_name}"
+      Crew.create(crew_name)
+    end
+
+    desc "run", "Run the AI crew"
+    option :crew, type: :string, required: true, desc: "Name of the crew to run"
+    def run
+      crew_name = options[:crew]
+      puts "Running crew: #{crew_name}"
+      crew = Crew.load(crew_name)
+      crew.execute
+    end
+
+    desc "list", "List all available crews"
+    def list
+      puts "Available crews:"
+      Crew.list.each do |crew|
+        puts "  - #{crew}"
+      end
+    end
+
+    desc "agent SUBCOMMAND ...ARGS", "Manage agents"
+    subcommand "agent", Agent::CLI
+
+    desc "task SUBCOMMAND ...ARGS", "Manage tasks"
+    subcommand "task", Task::CLI
+
+    desc "version", "Show version"
+    def version
+      puts "rcrewai version #{RCrewAI::VERSION}"
+    end
+  end
+end

data/lib/rcrewai/configuration.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RCrewAI
+  class Configuration
+    attr_accessor :llm_provider, :api_key, :model, :temperature, :max_tokens, :timeout
+    attr_accessor :openai_api_key, :anthropic_api_key, :google_api_key, :azure_api_key
+    attr_accessor :openai_model, :anthropic_model, :google_model, :azure_model
+    attr_accessor :base_url, :api_version, :deployment_name
+
+    def initialize
+      @llm_provider = :openai
+      @model = 'gpt-4'
+      @temperature = 0.1
+      @max_tokens = 4000
+      @timeout = 120
+      
+      # Default models for each provider
+      @openai_model = 'gpt-4'
+      @anthropic_model = 'claude-3-sonnet-20240229'
+      @google_model = 'gemini-pro'
+      @azure_model = 'gpt-4'
+      
+      # Load from environment variables
+      load_from_env
+    end
+
+    def api_key
+      case @llm_provider
+      when :openai
+        @openai_api_key || @api_key
+      when :anthropic
+        @anthropic_api_key || @api_key
+      when :google
+        @google_api_key || @api_key
+      when :azure
+        @azure_api_key || @api_key
+      else
+        @api_key
+      end
+    end
+
+    def model
+      case @llm_provider
+      when :openai
+        @openai_model || @model
+      when :anthropic
+        @anthropic_model || @model
+      when :google
+        @google_model || @model
+      when :azure
+        @azure_model || @model
+      else
+        @model
+      end
+    end
+
+    def validate!
+      raise ConfigurationError, "LLM provider must be set" if @llm_provider.nil?
+      raise ConfigurationError, "API key must be set for #{@llm_provider}" if api_key.nil? || api_key.empty?
+      raise ConfigurationError, "Model must be set for #{@llm_provider}" if model.nil? || model.empty?
+    end
+
+    def supported_providers
+      %i[openai anthropic google azure ollama]
+    end
+
+    def provider_supported?(provider)
+      supported_providers.include?(provider.to_sym)
+    end
+
+    private
+
+    def load_from_env
+      @openai_api_key = ENV['OPENAI_API_KEY']
+      @anthropic_api_key = ENV['ANTHROPIC_API_KEY'] || ENV['CLAUDE_API_KEY']
+      @google_api_key = ENV['GOOGLE_API_KEY'] || ENV['GEMINI_API_KEY']
+      @azure_api_key = ENV['AZURE_OPENAI_API_KEY']
+      
+      @api_key = ENV['LLM_API_KEY'] if @api_key.nil?
+      @base_url = ENV['LLM_BASE_URL'] if @base_url.nil?
+      @api_version = ENV['AZURE_API_VERSION'] if @api_version.nil?
+      @deployment_name = ENV['AZURE_DEPLOYMENT_NAME'] if @deployment_name.nil?
+    end
+  end
+
+  class ConfigurationError < Error; end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure(validate: true)
+    yield(configuration)
+    configuration.validate! if validate
+  end
+
+  def self.reset_configuration!
+    @configuration = Configuration.new
+  end
+end

data/lib/rcrewai/crew.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require_relative 'process'
+require_relative 'async_executor'
+
+module RCrewAI
+  class Crew
+    include AsyncExtensions
+    attr_reader :name, :agents, :tasks, :process_type
+    attr_accessor :verbose, :max_iterations
+
+    def initialize(name, **options)
+      @name = name
+      @agents = []
+      @tasks = []
+      @process_type = options.fetch(:process, :sequential)
+      @verbose = options.fetch(:verbose, false)
+      @max_iterations = options.fetch(:max_iterations, 10)
+      @process_instance = nil
+      validate_process_type!
+    end
+
+    def add_agent(agent)
+      @agents << agent
+    end
+
+    def add_task(task)
+      @tasks << task
+    end
+
+    def execute(async: false, **async_options)
+      if async
+        execute_async(**async_options)
+      else
+        execute_sync
+      end
+    end
+
+    def execute_async(**options)
+      puts "Executing crew: #{name} (async #{process_type} process)"
+      
+      case process_type
+      when :sequential
+        execute_sequential_async(**options)
+      when :hierarchical
+        execute_hierarchical_async(**options)
+      when :consensual
+        execute_consensual_async(**options)
+      else
+        raise ConfigurationError, "Async execution not implemented for #{process_type} process"
+      end
+    end
+
+    def execute_sync
+      puts "Executing crew: #{name} (#{process_type} process)"
+      
+      # Create appropriate process instance
+      @process_instance = create_process_instance
+      
+      # Execute using the process
+      results = @process_instance.execute
+      
+      # Return formatted results
+      format_execution_results(results)
+    end
+
+    def process=(new_process)
+      @process_type = new_process.to_sym
+      validate_process_type!
+      @process_instance = nil  # Reset process instance
+    end
+
+    def self.create(name)
+      crew = new(name)
+      crew.save
+      puts "Crew '#{name}' created successfully!"
+      crew
+    end
+
+    def self.load(name)
+      # Load crew configuration from file
+      new(name)
+    end
+
+    def self.list
+      # List all available crews
+      ["example_crew", "research_crew", "development_crew"]
+    end
+
+    def save
+      # Save crew configuration to file
+      true
+    end
+
+    private
+
+    def validate_process_type!
+      valid_processes = [:sequential, :hierarchical, :consensual]
+      unless valid_processes.include?(process_type)
+        raise ConfigurationError, "Invalid process type: #{process_type}. Valid types: #{valid_processes.join(', ')}"
+      end
+    end
+
+    def create_process_instance
+      case process_type
+      when :sequential
+        Process::Sequential.new(self)
+      when :hierarchical
+        Process::Hierarchical.new(self)
+      when :consensual
+        Process::Consensual.new(self)
+      else
+        raise ConfigurationError, "Unsupported process type: #{process_type}"
+      end
+    end
+
+    def execute_sequential_async(**options)
+      executor = AsyncExecutor.new(**options)
+      
+      begin
+        dependency_graph = build_dependency_graph
+        results = executor.execute_tasks_async(tasks, dependency_graph)
+        
+        # Add crew metadata
+        results.merge(
+          crew: name,
+          process: :async_sequential
+        )
+      ensure
+        executor.shutdown
+      end
+    end
+
+    def execute_hierarchical_async(**options)
+      # For hierarchical async, we need to coordinate through the manager
+      manager_agent = find_manager_agent
+      unless manager_agent
+        raise Process::ProcessError, "Hierarchical async execution requires a manager agent"
+      end
+
+      puts "Manager #{manager_agent.name} coordinating async execution"
+      
+      executor = AsyncExecutor.new(**options)
+      
+      begin
+        # Build execution phases respecting dependencies
+        dependency_graph = build_dependency_graph
+        phases = organize_tasks_into_phases(tasks, dependency_graph)
+        
+        results = []
+        phases.each_with_index do |phase_tasks, phase_index|
+          puts "Manager delegating phase #{phase_index + 1}: #{phase_tasks.length} tasks"
+          
+          # Create delegation contexts for each task
+          phase_tasks.each do |task|
+            unless task.agent
+              # Manager assigns best agent for the task
+              task.instance_variable_set(:@agent, find_best_agent_for_task(task))
+            end
+            
+            # Add delegation context
+            add_delegation_context(task, manager_agent)
+          end
+          
+          # Execute phase concurrently
+          phase_results = executor.execute_tasks_async(phase_tasks, {})
+          results.concat(phase_results[:results])
+          
+          # Check if we should abort
+          failed_count = phase_results[:results].count { |r| r[:status] == :failed }
+          if failed_count > phase_tasks.length * 0.5
+            puts "Manager aborting execution due to high failure rate in phase #{phase_index + 1}"
+            break
+          end
+        end
+        
+        {
+          crew: name,
+          process: :async_hierarchical,
+          manager: manager_agent.name,
+          total_tasks: tasks.length,
+          completed_tasks: results.count { |r| r[:status] == :completed },
+          failed_tasks: results.count { |r| r[:status] == :failed },
+          results: results,
+          success_rate: results.empty? ? 0 : (results.count { |r| r[:status] == :completed }.to_f / results.length * 100).round(1)
+        }
+      ensure
+        executor.shutdown
+      end
+    end
+
+    def execute_consensual_async(**options)
+      # Simplified consensual async - execute in parallel with result aggregation
+      executor = AsyncExecutor.new(**options)
+      
+      begin
+        # All tasks can potentially run in parallel for consensual
+        results = executor.execute_tasks_async(tasks, {})
+        
+        results.merge(
+          crew: name,
+          process: :async_consensual
+        )
+      ensure
+        executor.shutdown
+      end
+    end
+
+    def build_dependency_graph
+      graph = {}
+      tasks.each do |task|
+        graph[task] = task.context || []
+      end
+      graph
+    end
+
+    def organize_tasks_into_phases(tasks, dependency_graph)
+      phases = []
+      remaining_tasks = tasks.dup
+      completed_task_names = Set.new
+
+      while remaining_tasks.any?
+        ready_tasks = remaining_tasks.select do |task|
+          dependencies = dependency_graph[task] || []
+          dependencies.all? { |dep| completed_task_names.include?(dep.name) }
+        end
+
+        if ready_tasks.empty?
+          phases << remaining_tasks
+          break
+        end
+
+        phases << ready_tasks
+        remaining_tasks -= ready_tasks
+        ready_tasks.each { |task| completed_task_names.add(task.name) }
+      end
+
+      phases
+    end
+
+    def find_manager_agent
+      agents.find { |agent| agent.is_manager? } ||
+      agents.find { |agent| agent.allow_delegation }
+    end
+
+    def find_best_agent_for_task(task)
+      # Simple heuristic: match keywords
+      task_keywords = extract_keywords(task.description.downcase)
+      
+      # Filter out manager agents first
+      non_manager_agents = agents.reject(&:is_manager?)
+      return nil if non_manager_agents.empty?
+      
+      best_agent = non_manager_agents.max_by do |agent|
+        agent_keywords = extract_keywords("#{agent.role} #{agent.goal}".downcase)
+        common_keywords = (task_keywords & agent_keywords).length
+        tool_bonus = agent.tools.any? ? 0.5 : 0
+        common_keywords + tool_bonus
+      end
+
+      best_agent
+    end
+
+    def extract_keywords(text)
+      stopwords = %w[the a an and or but in on at to for of with by is are was were be been being have has had do does did will would could should]
+      text.split(/\W+/).reject { |w| w.length < 3 || stopwords.include?(w) }
+    end
+
+    def add_delegation_context(task, manager_agent)
+      delegation_context = {
+        manager: manager_agent.name,
+        delegation_reason: "Assigned by #{manager_agent.role} for optimal task execution",
+        coordination_notes: "Part of async hierarchical execution",
+        async_execution: true
+      }
+      
+      task.instance_variable_set(:@delegation_context, delegation_context)
+    end
+
+    def format_execution_results(results)
+      {
+        crew: name,
+        process: process_type,
+        total_tasks: results.length,
+        completed_tasks: results.count { |r| r[:status] == :completed },
+        failed_tasks: results.count { |r| r[:status] == :failed },
+        results: results,
+        success_rate: results.empty? ? 0.0 : (results.count { |r| r[:status] == :completed }.to_f / results.length * 100).round(1)
+      }
+    end
+  end
+end