active_genie 0.30.3 → 0.30.8

data/lib/active_genie/ranker/scoring.rb

@@ -12,14 +12,12 @@ module ActiveGenie
       def initialize(players, criteria, juries: [], config: nil)
         @players = Entities::Players.new(players)
         @criteria = criteria
-        @config = ActiveGenie.configuration.merge(config)
+        @initial_config = config
         @juries = Array(juries).compact.uniq
       end
 
       def call
-        @config.log.additional_context = { ranker_scoring_id: }
-
-        ActiveGenie::FiberByBatch.call(players_without_score, config: @config) do |player|
+        ActiveGenie::FiberByBatch.call(players_without_score, config:) do |player|
           player.score = generate_score(player)
         end
       end
@@ -31,14 +29,16 @@ module ActiveGenie
       end
 
       def generate_score(player)
-        score, reasoning = ActiveGenie::Scorer.by_jury_bench(
+        result = ActiveGenie::Scorer.by_jury_bench(
           player.content,
           @criteria,
           @juries,
-          config: @config
-        ).values_at('final_score', 'final_reasoning')
+          config:
+        )
+        score = result.data.to_i
+        reasoning = result.reasoning
 
-        @config.logger.call({ code: :new_score, player_id: player.id, score:, reasoning: })
+        ActiveGenie.logger.call({ code: :new_score, player_id: player.id, score:, reasoning: }, config:)
 
         score
       end
@@ -48,9 +48,9 @@ module ActiveGenie
           response = ActiveGenie::Lister.juries(
             [@players.sample.content, @players.sample.content].join("\n\n"),
             @criteria,
-            config: @config
+            config:
           )
-          @config.logger.call({ code: :new_juries, juries: response })
+          ActiveGenie.logger.call({ code: :new_juries, juries: response }, config:)
           response
         end
       end
@@ -58,11 +58,20 @@ module ActiveGenie
       def ranker_scoring_id
         @ranker_scoring_id ||= begin
           player_ids = players_without_score.map(&:id).join(',')
-          ranker_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+          ranker_unique_key = [player_ids, @criteria].join('-')
 
           "#{Digest::MD5.hexdigest(ranker_unique_key)}-scoring"
         end
       end
+
+      def config
+        @config ||= ActiveGenie.new_configuration(
+          DeepMerge.call(
+            @initial_config,
+            { log: { additional_context: { ranker_scoring_id: } } }
+          )
+        )
+      end
     end
   end
 end

data/lib/active_genie/ranker/tournament.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'entities/players'
+require_relative '../entities/players'
 require_relative 'free_for_all'
 require_relative 'elo'
 require_relative 'scoring'
@@ -30,33 +30,30 @@ require_relative 'scoring'
 # @return [Hash] Final ranked player results
 module ActiveGenie
   module Ranker
-    class Tournament
-      def self.call(...)
-        new(...).call
-      end
-
+    class Tournament < ActiveGenie::BaseModule
       def initialize(players, criteria, juries: [], config: {})
         @players = Entities::Players.new(players)
         @criteria = criteria
         @juries = Array(juries).compact.uniq
-        @config = ActiveGenie.configuration.merge(config)
+        super(config:)
       end
 
       def call
-        @config.log.additional_context = { ranker_id: }
-
         set_initial_player_scores!
         eliminate_obvious_bad_players!
 
         while @players.elo_eligible?
-          elo_report = run_elo_round!
+          elo_result = run_elo_round!
           eliminate_lower_tier_players!
-          rebalance_players!(elo_report)
+          rebalance_players!(elo_result)
         end
 
         run_free_for_all!
 
-        sorted_players
+        ActiveGenie::Result.new(
+          data: sorted_players.map(&:content),
+          metadata: @players.map(&:to_h)
+        )
       end
 
       ELIMINATION_VARIATION = 'variation_too_high'
@@ -65,12 +62,7 @@ module ActiveGenie
       private
 
       def set_initial_player_scores!
-        Scoring.call(
-          @players,
-          @criteria,
-          juries: @juries,
-          config: @config
-        )
+        Scoring.call(@players, @criteria, juries: @juries, config:)
       end
 
       def eliminate_obvious_bad_players!
@@ -80,50 +72,46 @@ module ActiveGenie
       end
 
       def run_elo_round!
-        Elo.call(
-          @players,
-          @criteria,
-          config: @config
-        )
+        Elo.call(@players, @criteria, config:)
       end
 
       def eliminate_lower_tier_players!
         @players.calc_lower_tier.each { |player| player.eliminated = ELIMINATION_RELEGATION }
       end
 
-      def rebalance_players!(elo_report)
-        return if elo_report[:highest_elo_diff].negative?
+      def rebalance_players!(elo_result)
+        return if elo_result.metadata[:highest_elo_diff].negative?
 
         @players.eligible.each do |player|
-          next if elo_report[:players_in_round].include?(player.id)
+          next if elo_result.metadata[:players_in_round].include?(player.id)
 
-          player.elo += elo_report[:highest_elo_diff]
+          player.elo += elo_result.metadata[:highest_elo_diff]
         end
       end
 
       def run_free_for_all!
-        FreeForAll.call(
-          @players,
-          @criteria,
-          config: @config
-        )
+        FreeForAll.call(@players, @criteria, config:)
       end
 
       def sorted_players
         players = @players.sorted
-        @config.logger.call({ ranker_id:, code: :ranker_final, players: players.map(&:to_h) })
+        ActiveGenie.logger.call({ ranker_id:, code: :ranker_final, players: players.map(&:to_h) }, config:)
 
-        players.map(&:to_h)
+        players
       end
 
       def ranker_id
         @ranker_id ||= begin
           player_ids = @players.map(&:id).join(',')
-          ranker_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+          ranker_unique_key = [player_ids, @criteria].join('-')
 
           Digest::MD5.hexdigest(ranker_unique_key)
         end
       end
+
+      def module_config
+        { log: { additional_context: { ranker_id: } } }
+      end
     end
   end
 end

data/lib/active_genie/scorer/jury_bench.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../providers/unified_provider'
+require_relative '../utils/text_case'
 
 module ActiveGenie
   module Scorer
@@ -17,7 +18,7 @@ module ActiveGenie
     # @example Usage with automatic jury recommendation
     #   JuryBench.call("Sample text", "Evaluate technical accuracy")
     #
-    class JuryBench
+    class JuryBench < ActiveGenie::BaseModule
       # @param text [String] The text content to be evaluated
       # @param criteria [String] The evaluation criteria or rubric to assess against
       # @param juries [Array<String>] Optional list of specific juries. If empty,
@@ -26,15 +27,11 @@ module ActiveGenie
       # @return [Hash] The evaluation result containing the scores and reasoning
       #   @return [Number] :final_score The final score of the text based on the criteria and juries
       #   @return [String] :final_reasoning Detailed explanation of why the final score was reached
-      def self.call(...)
-        new(...).call
-      end
-
       def initialize(text, criteria, juries = [], config: {})
         @text = text
         @criteria = criteria
         @param_juries = Array(juries).compact.uniq
-        @initial_config = config
+        super(config:)
       end
 
       def call
@@ -44,24 +41,17 @@ module ActiveGenie
           {  role: 'user', content: "Text to score: #{@text}" }
         ]
 
-        result = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
+        provider_response = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
           messages,
           build_function,
           config:
         )
 
-        result['final_score'] = 0 if result['final_score'].nil?
-
-        config.logger.call({
-                             code: :Scorer,
-                             text: @text[0..30],
-                             criteria: @criteria[0..30],
-                             juries: juries,
-                             score: result['final_score'],
-                             reasoning: result['final_reasoning']
-                           })
-
-        result
+        ActiveGenie::Result.new(
+          data: provider_response['final_score'] || 0,
+          reasoning: provider_response['final_reasoning'],
+          metadata: provider_response
+        )
       end
 
       PROMPT = File.read(File.join(__dir__, 'jury_bench.prompt.md'))
@@ -84,11 +74,12 @@ module ActiveGenie
         @properties ||= begin
           tmp = {}
           juries.each do |jury|
-            tmp["#{jury}_reasoning"] = {
+            jury_key = ActiveGenie::TextCase.underscore(jury)
+            tmp["#{jury_key}_reasoning"] = {
               type: 'string',
               description: "The reasoning of the Scorer process by #{jury}."
             }
-            tmp["#{jury}_score"] = {
+            tmp["#{jury_key}_score"] = {
               type: 'number',
               description: "The score given by #{jury}.",
               min: 0,
@@ -113,17 +104,12 @@ module ActiveGenie
         @juries ||= if @param_juries.any?
                       @param_juries
                     else
-                      ::ActiveGenie::Lister::Juries.call(@text, @criteria, config:)
+                      ::ActiveGenie::Lister::Juries.call(@text, @criteria, config:).data
                     end
       end
 
-      def config
-        @config ||= begin
-          c = ActiveGenie.configuration.merge(@initial_config)
-          c.llm.recommended_model = 'deepseek-chat' unless c.llm.recommended_model
-
-          c
-        end
+      def module_config
+        { llm: { recommended_model: 'deepseek-chat' } }
       end
     end
   end

data/lib/active_genie/utils/base_module.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'call_wrapper'
+
+module ActiveGenie
+  class BaseModule
+    prepend CallWrapper
+
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(config: {})
+      @initial_config = config || {}
+    end
+
+    def call
+      raise NotImplementedError, 'Subclasses must implement the `call` method'
+    end
+
+    def config
+      @config ||= ActiveGenie.new_configuration(
+        ActiveGenie::DeepMerge.call(
+          @initial_config.to_h,
+          module_config
+        )
+      )
+    end
+
+    def module_config
+      {}
+    end
+  end
+end

data/lib/active_genie/utils/call_wrapper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  module CallWrapper
+    def call(*, &)
+      response = super # Call the original method
+
+      if defined?(config)
+        ActiveGenie.logger.call(
+          {
+            code: self.class.name,
+            response: response.to_h
+          }, config:
+        )
+      end
+
+      response
+    end
+  end
+end

data/lib/active_genie/utils/deep_merge.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  module DeepMerge
+    module_function
+
+    def call(first_hash, second_hash)
+      merger = proc { |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
+      first_hash.to_h.merge(second_hash.to_h, &merger)
+    end
+  end
+end

data/lib/active_genie/utils/fiber_by_batch.rb

@@ -8,9 +8,9 @@ module ActiveGenie
 
     def call(items, config:, &block)
       items.each_slice(config.llm.max_fibers).to_a.each do |batch|
-        Async do
+        Async do |task|
           tasks = batch.map do |item|
-            Async { block.call(item) }
+            task.async { block.call(item) }
           end
 
           tasks.each(&:wait)

data/lib/active_genie/utils/text_case.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  module TextCase
+    module_function
+
+    def underscore(camel_cased_word)
+      return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
+
+      word = camel_cased_word.to_s.gsub('::', '/')
+      word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, '_')
+      word.tr!('-', '_')
+      word.tr!(' ', '_')
+      word.downcase!
+      word
+    end
+  end
+end

data/lib/active_genie.rb

@@ -3,10 +3,9 @@
 require_relative 'active_genie/logger'
 require_relative 'active_genie/configuration'
 
-require_relative 'active_genie/configs/providers/openai_config'
-require_relative 'active_genie/configs/providers/google_config'
-require_relative 'active_genie/configs/providers/anthropic_config'
-require_relative 'active_genie/configs/providers/deepseek_config'
+require_relative 'active_genie/entities/result'
+require_relative 'active_genie/utils/base_module'
+require_relative 'active_genie/utils/deep_merge'
 
 module ActiveGenie
   autoload :Extractor, File.join(__dir__, 'active_genie/extractor')
@@ -23,27 +22,26 @@ module ActiveGenie
     end
 
     def configuration
-      @configuration ||= initialize_configuration
+      @configuration ||= Configuration.new
     end
 
-    def load_tasks
-      return unless defined?(Rake)
+    def new_configuration(new_config)
+      return new_config if new_config.instance_of?(Configuration)
 
-      Rake::Task.define_task(:environment)
-      Dir.glob(File.join(__dir__, 'tasks', '*.rake')).each { |r| load r }
+      Configuration.new(
+        DeepMerge.call(@configuration.to_h, new_config)
+      )
     end
 
-    private
-
-    def initialize_configuration
-      config = Configuration.new
+    def logger
+      @logger ||= Logger.new
+    end
 
-      config.providers.add(Config::Providers::OpenaiConfig)
-      config.providers.add(Config::Providers::GoogleConfig)
-      config.providers.add(Config::Providers::AnthropicConfig)
-      config.providers.add(Config::Providers::DeepseekConfig)
+    def load_tasks
+      return unless defined?(Rake)
 
-      config
+      Rake::Task.define_task(:environment)
+      Dir.glob(File.join(__dir__, 'tasks', '*.rake')).each { |r| load r }
     end
   end
 end

data/lib/tasks/test.rake

@@ -6,13 +6,71 @@ namespace :test do
   Rake::TestTask.new(:unit) do |t|
     t.pattern = 'test/unit/**/*_test.rb'
   end
+  desc 'Run unit tests'
+  task unit: :reset_env
 
   Rake::TestTask.new(:integration) do |t|
-    t.pattern = 'test/integration/**/*_test.rb' # Or use _spec.rb for RSpec
+    t.pattern = 'test/integration/**/*_test.rb'
   end
+  desc 'Run integration tests like install rails'
+  task integration: :reset_env
 
+  desc 'Run all tests (unit and integration)'
   task default: %i[unit integration]
+
+  desc 'Reset environment variables for API keys'
+  task :reset_env do
+    reset_environment_variables
+  end
+end
+
+desc 'Run all tests (unit and integration) or a specific test file'
+task :test, [:file_path] do |_t, args|
+  reset_environment_variables
+
+  if args[:file_path]
+    file_path, line_number = args[:file_path].split(':')
+
+    if line_number
+      test_name = find_test_name_at_line(file_path, line_number.to_i)
+
+      if test_name
+        sh "ruby -Itest #{file_path} --name #{test_name}"
+      else
+        puts "Warning: Could not find test method at line #{line_number}"
+        ruby "-Itest #{file_path}"
+      end
+    else
+      ruby "-Itest #{file_path}"
+    end
+  else
+    Rake::Task['test:unit'].invoke
+    Rake::Task['test:integration'].invoke
+  end
 end
 
-desc 'Run all tests (unit and integration)'
-task test: ['test:unit', 'test:integration']
+def find_test_name_at_line(file_path, line_number)
+  return nil unless File.exist?(file_path)
+
+  lines = File.readlines(file_path)
+  return nil if line_number > lines.length
+
+  (line_number - 1).downto(0) do |i|
+    line = lines[i]
+    if line =~ /^\s*def\s+(test_\w+)/
+      return Regexp.last_match(1)
+    elsif line =~ /^\s*test\s+['"](.+?)['"]\s+do/
+      test_desc = Regexp.last_match(1)
+      return "/#{test_desc}/"
+    end
+  end
+
+  nil
+end
+
+def reset_environment_variables
+  ENV['OPENAI_API_KEY'] = nil
+  ENV['GEMINI_API_KEY'] = nil
+  ENV['ANTHROPIC_API_KEY'] = nil
+  ENV['DEEPSEEK_API_KEY'] = nil
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.30.3
+  version: 0.30.8
 platform: ruby
 authors:
 - Radamés Roriz
@@ -24,8 +24,11 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 description: |
-  ActiveGenie is a Ruby gem that helps developers build reliable, future-proof GenAI features without worrying about changing models, prompts, or providers. Like Lodash for GenAI, it offers simple, reusable modules for tasks like extractor, comparator, scorer, and ranker, so you can focus on your app’s logic, not the shifting AI landscape.
-  Behind the scenes, a custom benchmarking system keeps everything consistent across LLM vendors and versions, release after release.
+  ActiveGenie is an enabler for creating reliable GenAI features, offering powerful, model-agnostic tools across any provider. It allows you to settle subjective comparisons with a `ActibeGenie::Comparator` module that stages a political debate, get accurate scores from an AI jury using `ActiveGenie::Scorer`, and rank large datasets using `ActiveGenie::Ranker`'s tournament-style system.
+  This reliability is built on three core pillars:
+  - Custom Benchmarking: Testing for consistency with every new version and model update.
+  - Reasoning Prompting: Utilizing human reasoning techniques (like debate and jury review) to control a model's reasoning.
+  - Overfitting Prompts: Highly specialized, and potentially model-specific, prompt for each module's purpose.
 email:
 - radames@roriz.dev
 executables: []
@@ -43,7 +46,7 @@ files:
 - lib/active_genie/comparator/fight.json
 - lib/active_genie/comparator/fight.prompt.md
 - lib/active_genie/comparator/fight.rb
-- lib/active_genie/configs/comparator_config.rb
+- lib/active_genie/configs/base_config.rb
 - lib/active_genie/configs/extractor_config.rb
 - lib/active_genie/configs/lister_config.rb
 - lib/active_genie/configs/llm_config.rb
@@ -55,13 +58,19 @@ files:
 - lib/active_genie/configs/providers/provider_base.rb
 - lib/active_genie/configs/providers_config.rb
 - lib/active_genie/configs/ranker_config.rb
-- lib/active_genie/configs/scorer_config.rb
 - lib/active_genie/configuration.rb
+- lib/active_genie/entities/player.rb
+- lib/active_genie/entities/players.rb
+- lib/active_genie/entities/result.rb
 - lib/active_genie/errors/invalid_log_output_error.rb
 - lib/active_genie/errors/invalid_model_error.rb
 - lib/active_genie/errors/invalid_provider_error.rb
 - lib/active_genie/errors/provider_server_error.rb
+- lib/active_genie/errors/without_available_provider_error.rb
 - lib/active_genie/extractor.rb
+- lib/active_genie/extractor/data.json
+- lib/active_genie/extractor/data.prompt.md
+- lib/active_genie/extractor/data.rb
 - lib/active_genie/extractor/explanation.json
 - lib/active_genie/extractor/explanation.prompt.md
 - lib/active_genie/extractor/explanation.rb
@@ -82,15 +91,17 @@ files:
 - lib/active_genie/providers/unified_provider.rb
 - lib/active_genie/ranker.rb
 - lib/active_genie/ranker/elo.rb
-- lib/active_genie/ranker/entities/player.rb
-- lib/active_genie/ranker/entities/players.rb
 - lib/active_genie/ranker/free_for_all.rb
 - lib/active_genie/ranker/scoring.rb
 - lib/active_genie/ranker/tournament.rb
 - lib/active_genie/scorer.rb
 - lib/active_genie/scorer/jury_bench.prompt.md
 - lib/active_genie/scorer/jury_bench.rb
+- lib/active_genie/utils/base_module.rb
+- lib/active_genie/utils/call_wrapper.rb
+- lib/active_genie/utils/deep_merge.rb
 - lib/active_genie/utils/fiber_by_batch.rb
+- lib/active_genie/utils/text_case.rb
 - lib/tasks/benchmark.rake
 - lib/tasks/install.rake
 - lib/tasks/templates/active_genie.rb
@@ -120,5 +131,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: 'The Lodash for GenAI: Real Value + Consistent + Model-Agnostic'
+summary: 'The Lodash for GenAI: Consistent + Model-Agnostic'
 test_files: []

data/lib/active_genie/configs/comparator_config.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveGenie
-  module Config
-    # rubocop:disable Lint/EmptyClass
-    class ComparatorConfig
-    end
-    # rubocop:enable Lint/EmptyClass
-  end
-end

data/lib/active_genie/configs/scorer_config.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveGenie
-  module Config
-    # rubocop:disable Lint/EmptyClass
-    class ScorerConfig
-    end
-    # rubocop:enable Lint/EmptyClass
-  end
-end