active_genie 0.0.10 → 0.0.18

data/lib/tasks/benchmark.rake

@@ -0,0 +1,27 @@
+
+namespace :active_genie do
+  desc "Run benchmarks, optionally for a specific module (e.g., rake active_genie:benchmark[data_extractor])"
+  task :benchmark, [:module_name] do |_, args|
+    Rake::TestTask.new(:run_benchmarks) do |t|
+      t.libs << "benchmark"
+      
+      if args[:module_name]
+        module_name = args[:module_name]
+        module_path = "benchmark/test_cases/#{module_name}/"
+        t.test_files = FileList["#{module_path}**/*_test.rb"]
+        puts "Running benchmarks for module: #{module_name}"
+      else
+        t.test_files = FileList["benchmark/test_cases/**/*_test.rb"]
+        puts "Running all benchmarks"
+      end
+      
+      t.warning = false
+    end
+    
+    begin
+      Rake::Task[:run_benchmarks].invoke
+    rescue => e
+      puts e
+    end
+  end
+end

metadata

@@ -1,114 +1,103 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.18
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies: []
-description: "# ActiveGenie \U0001F9DE‍♂️\n> Transform your Ruby application with
-  powerful, production-ready GenAI features\n\n[![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)\n[![Ruby](https://github.com/roriz/active_genie/actions/workflows/ruby.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/ruby.yml)\n\nActiveGenie
-  is a Ruby gem that provides a polished, production-ready interface for working with
-  Generative AI (GenAI) models. Just like ActiveStorage simplifies file handling in
-  Rails, ActiveGenie makes it effortless to integrate GenAI capabilities into your
-  Ruby applications.\n\n## Features\n\n- \U0001F3AF **Data Extraction**: Extract structured
-  data from unstructured text with type validation\n- \U0001F4CA **Smart Scoring**:
-  Multi-reviewer evaluation system with automatic expert selection\n- \U0001F4AD **Leaderboard**:
-  Consistent rank items based on custom criteria, using multiple tecniques of ranking\n\n##
-  Installation\n\n1. Add to your Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2.
+description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop reinventing
+  the wheel\n\n[![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)\n[![Ruby](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml)\n\nActiveGenie
+  is a Ruby gem that provides valuable solutions powered by Generative AI (GenAI)
+  models. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules reach
+  real value fast and reliable.\nActiveGenie is backed by a custom benchmarking system
+  that ensures consistent quality and performance across different models and providers
+  in every release.\n\n## Installation\n\n1. Add to your Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2.
   Install the gem:\n```shell\nbundle install\n```\n\n3. Generate the configuration:\n```shell\necho
   \"ActiveGenie.load_tasks\" >> Rakefile\nrails g active_genie:install\n```\n\n4.
   Configure your credentials in `config/initializers/active_genie.rb`:\n```ruby\nActiveGenie.configure
   do |config|\n  config.openai.api_key = ENV['OPENAI_API_KEY']\nend\n```\n\n## Quick
-  Start\n\n### Data Extractor\nExtract structured data from text using AI-powered
+  Start\n\n### Data Extractor\n\nExtract structured data from text using AI-powered
   analysis, handling informal language and complex expressions.\n\n```ruby\ntext =
   \"Nike Air Max 90 - Size 42 - $199.99\"\nschema = {\n  brand: { \n    type: 'string',\n
   \   enum: [\"Nike\", \"Adidas\", \"Puma\"]\n  },\n  price: { \n    type: 'number',\n
-  \   minimum: 0\n  },\n  size: {\n    type: 'integer',\n    minimum: 35,\n    maximum:
-  46\n  }\n}\n\nresult = ActiveGenie::DataExtractor.call(text, schema)\n# => { \n#
-  \     brand: \"Nike\", \n#      brand_explanation: \"Brand name found at start of
-  text\",\n#      price: 199.99,\n#      price_explanation: \"Price found in USD format
-  at end\",\n#      size: 42,\n#      size_explanation: \"Size explicitly stated in
-  the middle\"\n#    }\n```\n\nFeatures:\n- Structured data extraction with type validation\n-
-  Schema-based extraction with custom constraints\n- Informal text analysis (litotes,
-  hedging)\n- Detailed explanations for extracted values\n\nSee the [Data Extractor
-  README](lib/active_genie/data_extractor/README.md) for informal text processing,
-  advanced schemas, and detailed interface documentation.\n\n### Scoring\nText evaluation
-  system that provides detailed scoring and feedback using multiple expert reviewers.
-  Get balanced scoring through AI-powered expert reviewers that automatically adapt
-  to your content.\n\n```ruby\ntext = \"The code implements a binary search algorithm
-  with O(log n) complexity\"\ncriteria = \"Evaluate technical accuracy and clarity\"\n\nresult
-  = ActiveGenie::Scoring.basic(text, criteria)\n# => {\n#      algorithm_expert_score:
-  95,\n#      algorithm_expert_reasoning: \"Accurately describes binary search and
-  its complexity\",\n#      technical_writer_score: 90,\n#      technical_writer_reasoning:
-  \"Clear and concise explanation of the algorithm\",\n#      final_score: 92.5\n#
-  \   }\n```\n\nFeatures:\n- Multi-reviewer evaluation with automatic expert selection\n-
-  Detailed feedback with scoring reasoning\n- Customizable reviewer weights\n- Flexible
-  evaluation criteria\n\nSee the [Scoring README](lib/active_genie/scoring/README.md)
+  \   minimum: 0\n  },\n  size: {\n    type: 'number',\n    minimum: 35,\n    maximum:
+  46\n  }\n}\n\nresult = ActiveGenie::DataExtractor.call(\n  text,\n  schema,\n  config:
+  { provider: :openai, model: 'gpt-4o-mini' } # optional\n)\n# => { \n#      brand:
+  \"Nike\", \n#      brand_explanation: \"Brand name found at start of text\",\n#
+  \     price: 199.99,\n#      price_explanation: \"Price found in USD format at end\",\n#
+  \     size: 42,\n#      size_explanation: \"Size explicitly stated in the middle\"\n#
+  \   }\n```\n\n*Recommended model*: `gpt-4o-mini`\n\nFeatures:\n- Structured data
+  extraction with type validation\n- Schema-based extraction with custom constraints\n-
+  Informal text analysis (litotes, hedging)\n- Detailed explanations for extracted
+  values\n\nSee the [Data Extractor README](lib/active_genie/data_extractor/README.md)
+  for informal text processing, advanced schemas, and detailed interface documentation.\n\n###
+  Scoring\nText evaluation system that provides detailed scoring and feedback using
+  multiple expert reviewers. Get balanced scoring through AI-powered expert reviewers
+  that automatically adapt to your content.\n\n```ruby\ntext = \"The code implements
+  a binary search algorithm with O(log n) complexity\"\ncriteria = \"Evaluate technical
+  accuracy and clarity\"\n\nresult = ActiveGenie::Scoring.basic(\n  text,\n  criteria,\n
+  \ config: { provider: :anthropic, model: 'claude-3-5-haiku-20241022' } # optional\n)\n#
+  => {\n#      algorithm_expert_score: 95,\n#      algorithm_expert_reasoning: \"Accurately
+  describes binary search and its complexity\",\n#      technical_writer_score: 90,\n#
+  \     technical_writer_reasoning: \"Clear and concise explanation of the algorithm\",\n#
+  \     final_score: 92.5\n#    }\n```\n\n*Recommended model*: `claude-3-5-haiku-20241022`\n\nFeatures:\n-
+  Multi-reviewer evaluation with automatic expert selection\n- Detailed feedback with
+  scoring reasoning\n- Customizable reviewer weights\n- Flexible evaluation criteria\n\nSee
+  the [Scoring README](lib/active_genie/scoring/README.md) for advanced usage, custom
+  reviewers, and detailed interface documentation.\n\n### Battle\nAI-powered battle
+  evaluation system that determines winners between two players based on specified
+  criteria.\n\n```ruby\nrequire 'active_genie'\n\nplayer_1 = \"Implementation uses
+  dependency injection for better testability\"\nplayer_2 = \"Code has high test coverage
+  but tightly coupled components\"\ncriteria = \"Evaluate code quality and maintainability\"\n\nresult
+  = ActiveGenie::Battle.call(\n  player_1,\n  player_2,\n  criteria,\n  config: {
+  provider: :google, model: 'gemini-2.0-flash-lite' } # optional\n)\n# => {\n#      winner_player:
+  \"Implementation uses dependency injection for better testability\",\n#      reasoning:
+  \"Player 1 implementation demonstrates better maintainability through dependency
+  injection, \n#                 which allows for easier testing and component replacement.
+  While Player 2 has good test coverage, \n#                 the tight coupling makes
+  the code harder to maintain and modify.\",\n#      what_could_be_changed_to_avoid_draw:
+  \"Focus on specific architectural patterns and design principles\"\n#    }\n```\n\n*Recommended
+  model*: `gemini-2.0-flash-lite`\n\nFeatures:\n- Multi-reviewer evaluation with automatic
+  expert selection\n- Detailed feedback with scoring reasoning\n- Customizable reviewer
+  weights\n- Flexible evaluation criteria\n\nSee the [Battle README](lib/active_genie/battle/README.md)
   for advanced usage, custom reviewers, and detailed interface documentation.\n\n###
-  Battle\nAI-powered battle evaluation system that determines winners between two
-  players based on specified criteria.\n\n```ruby\nrequire 'active_genie'\n\nplayer_a
-  = \"Implementation uses dependency injection for better testability\"\nplayer_b
-  = \"Code has high test coverage but tightly coupled components\"\ncriteria = \"Evaluate
-  code quality and maintainability\"\n\nresult = ActiveGenie::Battle.call(player_a,
-  player_b, criteria)\n# => {\n#      winner_player: \"Implementation uses dependency
-  injection for better testability\",\n#      reasoning: \"Player A's implementation
-  demonstrates better maintainability through dependency injection, \n#                 which
-  allows for easier testing and component replacement. While Player B has good test
-  coverage, \n#                 the tight coupling makes the code harder to maintain
-  and modify.\",\n#      what_could_be_changed_to_avoid_draw: \"Focus on specific
-  architectural patterns and design principles\"\n#    }\n```\n\nFeatures:\n- Multi-reviewer
-  evaluation with automatic expert selection\n- Detailed feedback with scoring reasoning\n-
-  Customizable reviewer weights\n- Flexible evaluation criteria\n\nSee the [Battle
-  README](lib/active_genie/battle/README.md) for advanced usage, custom reviewers,
-  and detailed interface documentation.\n\n### League\nThe League module provides
-  competitive ranking through multi-stage evaluation:\n\n\n```ruby\nrequire 'active_genie'\n\nplayers
-  = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']\ncriteria
-  = \"Best one to be used into a high changing environment\"\n\nresult = ActiveGenie::League.call(players,
-  criteria)\n# => {\n#      winner_player: \"gRPC API\",\n#      reasoning: \"gRPC
-  API is the best one to be used into a high changing environment\",\n#    }\n```\n\n-
+  Ranking\nThe Ranking module provides competitive ranking through multi-stage evaluation:\n\n```ruby\nrequire
+  'active_genie'\n\nplayers = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API',
+  'Websocket API']\ncriteria = \"Best one to be used into a high changing environment\"\n\nresult
+  = ActiveGenie::Ranking.call(\n  players,\n  criteria,\n  config: { provider: :google,
+  model: 'gemini-2.0-flash-lite' } # optional\n)\n# => {\n#      winner_player: \"gRPC
+  API\",\n#      reasoning: \"gRPC API is the best one to be used into a high changing
+  environment\",\n#    }\n```\n\n*Recommended model*: `gemini-2.0-flash-lite`\n\n-
   **Multi-phase ranking system** combining expert scoring and ELO algorithms\n- **Automatic
   elimination** of inconsistent performers using statistical analysis\n- **Dynamic
   ranking adjustments** based on simulated pairwise battles, from bottom to top\n\nSee
-  the [League README](lib/active_genie/league/README.md) for implementation details,
-  configuration, and advanced ranking strategies.\n\n### Summarizer (WIP)\nThe summarizer
-  is a tool that can be used to summarize a given text. It uses a set of rules to
-  summarize the text out of the box. Uses the best practices of prompt engineering
-  and engineering to make the summarization as accurate as possible.\n\n```ruby\nrequire
-  'active_genie'\n\ntext = \"Example text to be summarized. The fox jumps over the
-  dog\"\nsummarized_text = ActiveGenie::Summarizer.call(text)\nputs summarized_text
-  # => \"The fox jumps over the dog\"\n```\n\n### Language detector (WIP)\nThe language
-  detector is a tool that can be used to detect the language of a given text. It uses
-  a set of rules to detect the language of the text out of the box. Uses the best
-  practices of prompt engineering and engineering to make the language detection as
-  accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext = \"Example text
-  to be detected\"\nlanguage = ActiveGenie::LanguageDetector.call(text)\nputs language
-  # => \"en\"\n```\n\n### Translator (WIP)\nThe translator is a tool that can be used
-  to translate a given text. It uses a set of rules to translate the text out of the
-  box. Uses the best practices of prompt engineering and engineering to make the translation
-  as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext = \"Example
-  text to be translated\"\ntranslated_text = ActiveGenie::Translator.call(text, from:
-  'en', to: 'pt')\nputs translated_text # => \"Exemplo de texto a ser traduzido\"\n```\n\n###
-  Sentiment analyzer (WIP)\nThe sentiment analyzer is a tool that can be used to analyze
-  the sentiment of a given text. It uses a set of rules to analyze the sentiment of
-  the text out of the box. Uses the best practices of prompt engineering and engineering
-  to make the sentiment analysis as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext
-  = \"Example text to be analyzed\"\nsentiment = ActiveGenie::SentimentAnalyzer.call(text)\nputs
-  sentiment # => \"positive\"\n```\n\n## Configuration\n\n| Config | Description |
-  Default |\n|--------|-------------|---------|\n| `provider` | LLM provider (openai,
-  anthropic, etc) | `nil` |\n| `model` | Model to use | `nil` |\n| `api_key` | Provider
-  API key | `nil` |\n| `timeout` | Request timeout in seconds | `5` |\n| `max_retries`
-  | Maximum retry attempts | `3` |\n\n> **Note:** Each module can append its own set
-  of configuration, see the individual module documentation for details.\n\n## Contributing\n\n1.
-  Fork the repository\n2. Create your feature branch (`git checkout -b feature/amazing-feature`)\n3.
-  Commit your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch
-  (`git push origin feature/amazing-feature`)\n5. Open a Pull Request\n## License\n\nThis
-  project is licensed under the MIT License - see the [LICENSE](LICENSE) file for
-  details.\n"
+  the [Ranking README](lib/active_genie/ranking/README.md) for implementation details,
+  configuration, and advanced ranking strategies.\n\n### Text Summarizer (Future)\n###
+  Categorizer (Future)\n### Language detector (Future)\n### Translator (Future)\n###
+  Sentiment analyzer (Future)\n\n## Benchmarking \U0001F9EA\n\nActiveGenie includes
+  a comprehensive benchmarking system to ensure consistent, high-quality outputs across
+  different LLM models and providers.\n\n```ruby\n# Run all benchmarks\nbundle exec
+  rake active_genie:benchmark\n\n# Run benchmarks for a specific module\nbundle exec
+  rake active_genie:benchmark[data_extractor]\n```\n\n### Latest Results\n\n| Model
+  | Overall Precision |\n|-------|-------------------|\n| claude-3-5-haiku-20241022
+  | 92.25% |\n| gemini-2.0-flash-lite | 84.25% |\n| gpt-4o-mini | 62.75% |\n| deepseek-chat
+  | 57.25% |\n\nSee the [Benchmark README](benchmark/README.md) for detailed results,
+  methodology, and how to contribute to our test suite.\n\n## Configuration\n\n| Config
+  | Description | Default |\n|--------|-------------|---------|\n| `provider` | LLM
+  provider (openai, anthropic, etc) | `nil` |\n| `model` | Model to use | `nil` |\n|
+  `api_key` | Provider API key | `nil` |\n| `timeout` | Request timeout in seconds
+  | `5` |\n| `max_retries` | Maximum retry attempts | `3` |\n\n> **Note:** Each module
+  can append its own set of configuration, see the individual module documentation
+  for details.\n\n## Contributing\n\n1. Fork the repository\n2. Create your feature
+  branch (`git checkout -b feature/amazing-feature`)\n3. Commit your changes (`git
+  commit -m 'Add amazing feature'`)\n4. Push to the branch (`git push origin feature/amazing-feature`)\n5.
+  Open a Pull Request\n\n## License\n\nThis project is licensed under the Apache License
+  2.0 License - see the [LICENSE](LICENSE) file for details.\n"
 email:
 - radames@roriz.dev
 executables: []
@@ -122,28 +111,39 @@ files:
 - lib/active_genie/battle.rb
 - lib/active_genie/battle/README.md
 - lib/active_genie/battle/basic.rb
+- lib/active_genie/clients/anthropic_client.rb
+- lib/active_genie/clients/google_client.rb
+- lib/active_genie/clients/helpers/retry.rb
 - lib/active_genie/clients/openai_client.rb
 - lib/active_genie/clients/unified_client.rb
+- lib/active_genie/concerns/loggable.rb
 - lib/active_genie/configuration.rb
 - lib/active_genie/configuration/log_config.rb
-- lib/active_genie/configuration/openai_config.rb
+- lib/active_genie/configuration/providers/anthropic_config.rb
+- lib/active_genie/configuration/providers/base_config.rb
+- lib/active_genie/configuration/providers/deepseek_config.rb
+- lib/active_genie/configuration/providers/google_config.rb
+- lib/active_genie/configuration/providers/openai_config.rb
 - lib/active_genie/configuration/providers_config.rb
+- lib/active_genie/configuration/runtime_config.rb
 - lib/active_genie/data_extractor.rb
 - lib/active_genie/data_extractor/README.md
 - lib/active_genie/data_extractor/basic.rb
 - lib/active_genie/data_extractor/from_informal.rb
-- lib/active_genie/league.rb
-- lib/active_genie/league/README.md
-- lib/active_genie/league/elo_ranking.rb
-- lib/active_genie/league/free_for_all.rb
-- lib/active_genie/league/league.rb
-- lib/active_genie/league/player.rb
-- lib/active_genie/league/players_collection.rb
 - lib/active_genie/logger.rb
+- lib/active_genie/ranking.rb
+- lib/active_genie/ranking/README.md
+- lib/active_genie/ranking/elo_round.rb
+- lib/active_genie/ranking/free_for_all.rb
+- lib/active_genie/ranking/player.rb
+- lib/active_genie/ranking/players_collection.rb
+- lib/active_genie/ranking/ranking.rb
+- lib/active_genie/ranking/ranking_scoring.rb
 - lib/active_genie/scoring.rb
 - lib/active_genie/scoring/README.md
 - lib/active_genie/scoring/basic.rb
-- lib/active_genie/scoring/recommended_reviews.rb
+- lib/active_genie/scoring/recommended_reviewers.rb
+- lib/tasks/benchmark.rake
 - lib/tasks/install.rake
 - lib/tasks/templates/active_genie.rb
 homepage: https://github.com/Roriz/active_genie
@@ -163,7 +163,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/active_genie/configuration/openai_config.rb

@@ -1,56 +0,0 @@
-require_relative '../clients/openai_client'
-
-module ActiveGenie::Configuration
-  class OpenaiConfig
-    attr_writer :api_key, :organization, :api_url, :client,
-      :lower_tier_model, :middle_tier_model, :upper_tier_model
-
-    def api_key
-      @api_key || ENV['OPENAI_API_KEY']
-    end
-
-    def organization
-      @organization || ENV['OPENAI_ORGANIZATION']
-    end
-
-    def lower_tier_model
-      @lower_tier_model || 'gpt-4o-mini'
-    end
-
-    def middle_tier_model
-      @middle_tier_model || 'gpt-4o'
-    end
-
-    def upper_tier_model
-      @upper_tier_model || 'o1-preview'
-    end
-
-    def tier_to_model(tier)
-      {
-        lower_tier: lower_tier_model,
-        middle_tier: middle_tier_model,
-        upper_tier: upper_tier_model
-      }[tier&.to_sym]
-    end
-
-    def api_url
-      @api_url || 'https://api.openai.com/v1'
-    end
-
-    def client
-      @client ||= ::ActiveGenie::Clients::OpenaiClient.new(self)
-    end
-
-    def to_h(config = {})
-      {
-        api_key:,
-        organization:,
-        api_url:,
-        lower_tier_model:,
-        middle_tier_model:,
-        upper_tier_model:,
-        **config
-      }
-    end
-  end
-end

data/lib/active_genie/league/elo_ranking.rb

@@ -1,121 +0,0 @@
-require_relative '../battle/basic'
-
-module ActiveGenie::Leaderboard
-  class EloRanking
-    def self.call(players, criteria, config: {})
-      new(players, criteria, config:).call
-    end
-
-    def initialize(players, criteria, config: {})
-      @players = players
-      @criteria = criteria
-      @config = config
-      @start_time = Time.now
-    end
-
-    def call
-      @players.each(&:generate_elo_by_score)
-
-      round_count = 0
-      while @players.eligible_size > MINIMAL_PLAYERS_TO_BATTLE
-        round = create_round(@players.tier_relegation, @players.tier_defense)
-
-        round.each do |player_a, player_b|
-          winner, loser = battle(player_a, player_b) # This can take a while, can be parallelized
-          update_elo(winner, loser)
-          ActiveGenie::Logger.trace({ **log, step: :elo_battle, winner_id: winner.id, loser_id: loser.id, winner_elo: winner.elo, loser_elo: loser.elo })
-        end
-
-        eliminate_all_relegation_players
-        round_count += 1
-      end
-
-      ActiveGenie::Logger.info({ **log, step: :elo_end, round_count:, eligible_size: @players.eligible_size })
-      @players
-    end
-
-    private
-
-    MATCHS_PER_PLAYER = 3
-    LOSE_PENALTY = 15
-    MINIMAL_PLAYERS_TO_BATTLE = 10
-    K = 32
-
-    # Create a round of matches
-    # each round is exactly 1 regation player vs 3 defense players for all regation players
-    # each match is unique (player vs player)
-    # each defense player is battle exactly 3 times
-    def create_round(relegation_players, defense_players)
-      matches = []
-
-      relegation_players.each do |player_a|
-        player_enemies = []
-        MATCHS_PER_PLAYER.times do
-          defender = nil
-          while defender.nil? || player_enemies.include?(defender.id)
-            defender = defense_players.sample
-          end
-
-          matches << [player_a, defender].shuffle
-          player_enemies << defender.id
-        end
-      end
-
-      matches
-    end
-
-    def battle(player_a, player_b)
-      ActiveGenie::Battle.basic(
-        player_a,
-        player_b,
-        @criteria,
-        config:
-      ).values_at('winner', 'loser')
-    end
-
-    def update_elo(winner, loser)
-      return if winner.nil? || loser.nil?
-
-      new_winner_elo, new_loser_elo = calculate_new_elo(winner.elo, loser.elo)
-
-      winner.elo = [new_winner_elo, max_defense_elo].min
-      loser.elo = [new_loser_elo - LOSE_PENALTY, min_relegation_elo].max
-    end
-
-    def max_defense_elo
-      @players.tier_defense.max_by(&:elo).elo
-    end
-
-    def min_relegation_elo
-      @players.tier_relegation.min_by(&:elo).elo
-    end
-
-    # Read more about the formula on https://en.wikipedia.org/wiki/Elo_rating_system
-    def calculate_new_elo(winner_elo, loser_elo)
-      expected_score_a = 1 / (1 + 10**((loser_elo - winner_elo) / 400))
-      expected_score_b = 1 - expected_score_a
-
-      new_elo_winner = winner_elo + K * (1 - expected_score_a)
-      new_elo_loser = loser_elo + K * (1 - expected_score_b)
-
-      [new_elo_winner, new_elo_loser]
-    end
-
-    def eliminate_all_relegation_players
-      eliminations = @players.tier_relegation.size
-      @players.tier_relegation.each { |player| player.eliminated = 'tier_relegation' }
-      ActiveGenie::Logger.trace({ **log, step: :elo_round, eligible_size: @players.eligible_size, eliminations: })
-    end
-
-    def config
-      { **@config }
-    end
-
-    def log
-      {
-        **(@config.dig(:log) || {}),
-        duration: Time.now - @start_time
-      }
-    end
-  end
-end

data/lib/active_genie/league/free_for_all.rb

@@ -1,62 +0,0 @@
-require_relative '../battle/basic'
-
-module ActiveGenie::Leaderboard
-  class FreeForAll
-    def self.call(players, criteria, config: {})
-      new(players, criteria, config:).call
-    end
-
-    def initialize(players, criteria, config: {})
-      @players = players
-      @criteria = criteria
-      @config = config
-      @start_time = Time.now
-    end
-
-    def call
-      matches.each do |player_a, player_b|
-        winner, loser = battle(player_a, player_b)
-
-        if winner.nil? || loser.nil?
-          player_a.free_for_all[:draw] += 1
-          player_b.free_for_all[:draw] += 1
-        else
-          winner.free_for_all[:win] += 1
-          loser.free_for_all[:lose] += 1
-        end
-
-        ActiveGenie::Logger.trace({**log, step: :free_for_all_battle, winner_id: winner&.id, player_a_id: player_a.id, player_a_free_for_all_score: player_a.free_for_all_score, player_b_id: player_b.id, player_b_free_for_all_score: player_b.free_for_all_score })
-      end
-
-      @players
-    end
-
-    private
-
-    # TODO: reduce the number of matches based on transitivity.
-    #       For example, if A is better than B, and B is better than C, then A should clearly be better than C
-    def matches
-      @players.eligible.combination(2).to_a
-    end
-
-    def battle(player_a, player_b)
-      result = ActiveGenie::Battle.basic(
-        player_a,
-        player_b,
-        @criteria,
-        config:
-      )
-
-
-      result.values_at('winner', 'loser')
-    end
-
-    def config
-      { **@config }
-    end
-
-    def log
-      { **(@config.dig(:log) || {}), duration: Time.now - @start_time }
-    end
-  end
-end

data/lib/active_genie/league/league.rb

@@ -1,120 +0,0 @@
-require 'securerandom'
-
-require_relative './players_collection'
-require_relative './free_for_all'
-require_relative './elo_ranking'
-require_relative '../scoring/recommended_reviews'
-
-# This class orchestrates player ranking through multiple evaluation stages
-# using Elo ranking and free-for-all match simulations.
-# 1. Sets initial scores
-# 2. Eliminates low performers
-# 3. Runs Elo ranking (for large groups)
-# 4. Conducts free-for-all matches
-#
-# @example Basic usage
-#   League.call(players, criteria)
-#
-# @param param_players [Array] Collection of player objects to evaluate
-#   Example: ["Circle", "Triangle", "Square"]
-#            or
-#   [
-#     { content: "Circle", score: 10 },
-#     { content: "Triangle", score: 7 },
-#     { content: "Square", score: 5 }
-#   ]
-# @param criteria [String] Evaluation criteria configuration
-#   Example: "What is more similar to the letter 'O'?"
-# @param config [Hash] Additional configuration config
-#   Example: { model: "gpt-4o", api_key: ENV['OPENAI_API_KEY'] }
-# @return [Hash] Final ranked player results
-module ActiveGenie::League
-  class League
-    def self.call(param_players, criteria, config: {})
-      new(param_players, criteria, config:).call
-    end
-
-    def initialize(param_players, criteria, config: {})
-      @param_players = param_players
-      @criteria = criteria
-      @config = config
-      @league_id = SecureRandom.uuid
-      @start_time = Time.now
-    end
-
-    def call
-      set_initial_score_players
-      eliminate_obvious_bad_players
-      run_elo_ranking if players.eligible_size > 10
-      run_free_for_all
-
-      ActiveGenie::Logger.info({ **log, step: :league_end, top5: players.first(5).map(&:id) })
-      players.to_h
-    end
-
-    private
-
-    SCORE_VARIATION_THRESHOLD = 10
-
-    def set_initial_score_players
-      players_without_score = players.reject { |player| player.score }
-      players_without_score.each do |player|
-        player.score = generate_score(player.content) # This can take a while, can be parallelized
-        ActiveGenie::Logger.trace({ **log, step: :player_score, player_id: player.id, score: player.score })
-      end
-
-      ActiveGenie::Logger.info({ **log, step: :initial_score, evaluated_players: players_without_score.size })
-    end
-
-    def generate_score(content)
-      ActiveGenie::Scoring::Basic.call(content, @criteria, reviewers, config:)['final_score']
-    end
-
-    def eliminate_obvious_bad_players
-      eliminated_count = 0
-      while players.coefficient_of_variation >= SCORE_VARIATION_THRESHOLD
-        players.eligible.last.eliminated = 'variation_too_high'
-        eliminated_count += 1
-      end
-
-      ActiveGenie::Logger.info({ **log, step: :eliminate_obvious_bad_players, eliminated_count: })
-    end
-
-    def run_elo_ranking
-      EloRanking.call(players, @criteria, config:)
-    end
-
-    def run_free_for_all
-      FreeForAll.call(players, @criteria, config:)
-    end
-
-    def reviewers
-      [recommended_reviews['reviewer1'], recommended_reviews['reviewer2'], recommended_reviews['reviewer3']]
-    end
-
-    def recommended_reviews
-      @recommended_reviews ||= ActiveGenie::Scoring::RecommendedReviews.call(
-        [players.sample.content, players.sample.content].join("\n\n"),
-        @criteria,
-        config:
-      )
-    end
-
-    def players
-      @players ||= PlayersCollection.new(@param_players)
-    end
-
-    def config
-      { log:, **@config }
-    end
-
-    def log
-      {
-        **(@config.dig(:log) || {}),
-        league_id: @league_id,
-        league_start_time: @start_time,
-        duration: Time.now - @start_time
-      }
-    end
-  end
-end