rcrewai 0.2.1 → 0.4.0

data/lib/rcrewai/async_executor.rb

@@ -12,7 +12,7 @@ module RCrewAI
       @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,
@@ -20,7 +20,7 @@ module RCrewAI
         max_queue: @max_concurrency * 2,
         fallback_policy: :caller_runs
       )
-      
+
       @futures = {}
       @task_dependencies = {}
       @completed_tasks = Concurrent::Set.new
@@ -29,30 +29,30 @@ module RCrewAI
 
     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)
+        if failed_in_phase.positive? && 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
 
@@ -60,38 +60,36 @@ module RCrewAI
       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
+        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 StandardError => e
+        @logger.error "Task #{task.name} failed: #{e.message}"
+        results << { task: task, result: e.message, status: :failed }
       end
-      
+
       results
     end
 
     def shutdown
-      @logger.info "Shutting down async executor..."
+      @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
+      return if @thread_pool.wait_for_termination(30)
+
+      @logger.warn 'Thread pool did not shut down gracefully, forcing shutdown'
+      @thread_pool.kill
     end
 
     def stats
@@ -136,7 +134,7 @@ module RCrewAI
 
     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|
@@ -146,7 +144,7 @@ module RCrewAI
 
       # 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]
@@ -156,31 +154,33 @@ module RCrewAI
           @failed_tasks.add(result[:task])
         end
       end
-      
-      @logger.info "Phase #{phase_number} completed: #{phase_results.count { |r| r[:status] == :completed }}/#{phase_tasks.length} successful"
-      
+
+      @logger.info "Phase #{phase_number} completed: #{phase_results.count do |r|
+        r[:status] == :completed
+      end}/#{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
+      rescue StandardError => 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
@@ -189,7 +189,7 @@ module RCrewAI
 
     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
@@ -198,7 +198,7 @@ module RCrewAI
       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,
@@ -227,7 +227,7 @@ module RCrewAI
     module ClassMethods
       def execute_async(tasks, **options)
         executor = AsyncExecutor.new(**options)
-        
+
         begin
           results = executor.execute_tasks_async(tasks)
           results
@@ -245,4 +245,4 @@ module RCrewAI
       @thread_id
     end
   end
-end
+end

data/lib/rcrewai/cli.rb

@@ -2,14 +2,14 @@
 
 module RCrewAI
   class CLI < Thor
-    desc "new CREW_NAME", "Create a new AI crew"
+    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"
+    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}"
@@ -17,23 +17,23 @@ module RCrewAI
       crew.execute
     end
 
-    desc "list", "List all available crews"
+    desc 'list', 'List all available crews'
     def list
-      puts "Available crews:"
+      puts 'Available crews:'
       Crew.list.each do |crew|
         puts "  - #{crew}"
       end
     end
 
-    desc "agent SUBCOMMAND ...ARGS", "Manage agents"
-    subcommand "agent", Agent::CLI
+    desc 'agent SUBCOMMAND ...ARGS', 'Manage agents'
+    subcommand 'agent', Agent::CLI
 
-    desc "task SUBCOMMAND ...ARGS", "Manage tasks"
-    subcommand "task", Task::CLI
+    desc 'task SUBCOMMAND ...ARGS', 'Manage tasks'
+    subcommand 'task', Task::CLI
 
-    desc "version", "Show version"
+    desc 'version', 'Show version'
     def version
       puts "rcrewai version #{RCrewAI::VERSION}"
     end
   end
-end
+end

data/lib/rcrewai/configuration.rb

@@ -2,10 +2,11 @@
 
 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
+    attr_accessor :llm_provider, :api_key, :model, :temperature, :max_tokens, :timeout,
+                  :openai_api_key, :anthropic_api_key, :google_api_key, :azure_api_key,
+                  :openai_model, :anthropic_model, :google_model, :azure_model,
+                  :base_url, :api_version, :deployment_name,
+                  :pricing, :ollama_native_tools, :log_level
 
     def initialize
       @llm_provider = :openai
@@ -13,13 +14,17 @@ module RCrewAI
       @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'
-      
+
+      @pricing = nil
+      @ollama_native_tools = nil
+      @log_level = :info
+
       # Load from environment variables
       load_from_env
     end
@@ -54,8 +59,28 @@ module RCrewAI
       end
     end
 
+    # Returns a copy of this configuration with the given per-agent overrides
+    # applied. The original configuration is left untouched, so agents can each
+    # target a different provider/model without mutating global state.
+    #
+    #   config.with_overrides(provider: :anthropic, model: 'claude-3-opus-20240229')
+    def with_overrides(provider: nil, model: nil, api_key: nil, temperature: nil)
+      copy = dup
+      copy.llm_provider = provider.to_sym if provider
+      target = copy.llm_provider
+
+      copy.public_send("#{target}_model=", model) if model && copy.respond_to?("#{target}_model=")
+      copy.model = model if model
+
+      copy.public_send("#{target}_api_key=", api_key) if api_key && copy.respond_to?("#{target}_api_key=")
+      copy.api_key = api_key if api_key
+
+      copy.temperature = temperature unless temperature.nil?
+      copy
+    end
+
     def validate!
-      raise ConfigurationError, "LLM provider must be set" if @llm_provider.nil?
+      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
@@ -75,7 +100,7 @@ module RCrewAI
       @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?
@@ -97,4 +122,4 @@ module RCrewAI
   def self.reset_configuration!
     @configuration = Configuration.new
   end
-end
+end

data/lib/rcrewai/crew.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'logger'
 require_relative 'process'
 require_relative 'async_executor'
+require_relative 'events'
+require_relative 'planning'
 
 module RCrewAI
   class Crew
@@ -16,10 +19,20 @@ module RCrewAI
       @process_type = options.fetch(:process, :sequential)
       @verbose = options.fetch(:verbose, false)
       @max_iterations = options.fetch(:max_iterations, 10)
+      @planning = options.fetch(:planning, false)
+      @planning_llm = options[:planning_llm]
+      @planned = false
+      @knowledge = build_knowledge(options[:knowledge], options[:knowledge_sources])
       @process_instance = nil
       validate_process_type!
     end
 
+    attr_reader :knowledge, :stream_sink
+
+    def planning?
+      @planning
+    end
+
     def add_agent(agent)
       @agents << agent
     end
@@ -28,7 +41,15 @@ module RCrewAI
       @tasks << task
     end
 
-    def execute(async: false, **async_options)
+    def execute(async: false, stream: nil, **async_options, &block)
+      sinks = []
+      sinks << block if block_given?
+      Array(stream).each { |s| sinks << s } if stream
+      @stream_sink = sinks.empty? ? nil : RCrewAI::Events.fan_out(sinks)
+
+      distribute_knowledge if @knowledge
+      run_planning_pass if planning?
+
       if async
         execute_async(**async_options)
       else
@@ -36,9 +57,38 @@ module RCrewAI
       end
     end
 
+    # Runs the crew repeatedly, collecting feedback after each iteration and
+    # persisting it to +filename+ as JSON. +feedback+ is a callable
+    # ->(iteration, result) { "..." }; it defaults to prompting a human.
+    # Mirrors CrewAI's crew.train.
+    def train(n_iterations:, filename:, feedback: nil)
+      feedback ||= method(:default_training_feedback)
+      entries = []
+
+      (1..n_iterations).each do |iteration|
+        result = execute
+        note = feedback.call(iteration, result)
+        entries << { iteration: iteration, feedback: note }
+      end
+
+      write_training_file(filename, entries)
+      { iterations: n_iterations, filename: filename, entries: entries }
+    end
+
+    # Runs the crew repeatedly and scores each run. +scorer+ is a callable
+    # ->(result) { Float }; it defaults to the run's success_rate.
+    # Mirrors CrewAI's crew.test.
+    def test(n_iterations:, scorer: nil, model: nil) # rubocop:disable Lint/UnusedMethodArgument
+      scorer ||= ->(result) { result[:success_rate].to_f }
+      scores = (1..n_iterations).map { scorer.call(execute) }
+      average = scores.empty? ? 0.0 : (scores.sum / scores.length).round(2)
+
+      { iterations: n_iterations, scores: scores, average_score: average }
+    end
+
     def execute_async(**options)
       puts "Executing crew: #{name} (async #{process_type} process)"
-      
+
       case process_type
       when :sequential
         execute_sequential_async(**options)
@@ -53,13 +103,13 @@ module RCrewAI
 
     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
@@ -67,7 +117,7 @@ module RCrewAI
     def process=(new_process)
       @process_type = new_process.to_sym
       validate_process_type!
-      @process_instance = nil  # Reset process instance
+      @process_instance = nil # Reset process instance
     end
 
     def self.create(name)
@@ -84,7 +134,7 @@ module RCrewAI
 
     def self.list
       # List all available crews
-      ["example_crew", "research_crew", "development_crew"]
+      %w[example_crew research_crew development_crew]
     end
 
     def save
@@ -94,11 +144,47 @@ module RCrewAI
 
     private
 
+    def build_knowledge(knowledge, sources)
+      return knowledge if knowledge
+      return nil if sources.nil? || sources.empty?
+
+      Knowledge::Base.new(sources: sources)
+    end
+
+    def distribute_knowledge
+      @knowledge.build!
+      agents.each { |agent| agent.crew_knowledge = @knowledge if agent.respond_to?(:crew_knowledge=) }
+    end
+
+    def default_training_feedback(iteration, _result)
+      require_relative 'human_input'
+      response = HumanInput.new.request_input(
+        "Feedback for training iteration #{iteration} (press enter to skip):"
+      )
+      response.is_a?(Hash) ? response[:input].to_s : response.to_s
+    end
+
+    def write_training_file(filename, entries)
+      require 'json'
+      require 'fileutils'
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.write(filename, JSON.pretty_generate(entries))
+    end
+
+    def run_planning_pass
+      return if @planned
+
+      logger = Logger.new($stdout)
+      logger.level = verbose ? Logger::DEBUG : Logger::INFO
+      Planning.new(self, llm: LLMClient.resolve(@planning_llm), logger: logger).plan!
+      @planned = true
+    end
+
     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
+      valid_processes = %i[sequential hierarchical consensual]
+      return if valid_processes.include?(process_type)
+
+      raise ConfigurationError, "Invalid process type: #{process_type}. Valid types: #{valid_processes.join(', ')}"
     end
 
     def create_process_instance
@@ -116,11 +202,11 @@ module RCrewAI
 
     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,
@@ -134,38 +220,36 @@ module RCrewAI
     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
+      raise Process::ProcessError, 'Hierarchical async execution requires a manager agent' unless manager_agent
 
       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
@@ -173,7 +257,7 @@ module RCrewAI
             break
           end
         end
-        
+
         {
           crew: name,
           process: :async_hierarchical,
@@ -182,7 +266,13 @@ module RCrewAI
           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)
+          success_rate: if results.empty?
+                          0
+                        else
+                          (results.count do |r|
+                            r[:status] == :completed
+                          end.to_f / results.length * 100).round(1)
+                        end
         }
       ensure
         executor.shutdown
@@ -192,11 +282,11 @@ module RCrewAI
     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
@@ -239,30 +329,29 @@ module RCrewAI
     end
 
     def find_manager_agent
-      agents.find { |agent| agent.is_manager? } ||
-      agents.find { |agent| agent.allow_delegation }
+      agents.find(&:is_manager?) ||
+        agents.find(&: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|
+
+      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]
+      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
 
@@ -270,10 +359,10 @@ module RCrewAI
       delegation_context = {
         manager: manager_agent.name,
         delegation_reason: "Assigned by #{manager_agent.role} for optimal task execution",
-        coordination_notes: "Part of async hierarchical execution",
+        coordination_notes: 'Part of async hierarchical execution',
         async_execution: true
       }
-      
+
       task.instance_variable_set(:@delegation_context, delegation_context)
     end
 
@@ -285,8 +374,14 @@ module RCrewAI
         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)
+        success_rate: if results.empty?
+                        0.0
+                      else
+                        (results.count do |r|
+                          r[:status] == :completed
+                        end.to_f / results.length * 100).round(1)
+                      end
       }
     end
   end
-end
+end