active_genie 0.0.8 → 0.0.12

metadata

@@ -1,51 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.12
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-06 00:00:00.000000000 Z
+date: 2025-03-17 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
+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/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 **Sentiment
-  Analysis**: Advanced sentiment analysis with customizable rules\n- \U0001F512 **Safe
-  & Secure**: Built-in validation and sanitization\n- \U0001F6E0️ **Configurable**:
-  Supports multiple GenAI providers and models\n\n## Installation\n\n1. Add to your
-  Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2. Install the gem:\n```shell\nbundle
+  Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie simplifies
+  GenAI integration in your Ruby applications.\n\n## Features\n\n- \U0001F3AF **Data
+  Extraction**: Extract structured data from unstructured text with type validation\n-
+  \U0001F4CA **Data Scoring**: Multi-reviewer evaluation system\n- ⚔️ **Data Battle**:
+  Battle between two data like a political debate\n- \U0001F4AD **Data Ranking**:
+  Consistent rank data using scoring + elo ranking + battles\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. [Optional] Configure your credentials
-  in `config/active_genie.yml`:\n```yaml\nGPT-4o-mini:\n  api_key: <%= ENV['OPENAI_API_KEY']
-  %>\n  provider: \"openai\"\n\nclaude-3-5-sonnet:\n  api_key: <%= ENV['ANTHROPIC_API_KEY']
-  %>\n  provider: \"anthropic\"\n```\n\n> The first key will be used as default in
-  all modules, in this example `GPT-4o-mini`\n\n## Quick Start\n\n### Data Extractor\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.call(text, criteria)\n#
+  >> 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 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###
+  Data 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#
@@ -53,11 +49,11 @@ description: "# ActiveGenie \U0001F9DE‍♂️\n> Transform your Ruby applicati
   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_a
+  Data 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::Basic.call(player_a,
+  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
@@ -68,46 +64,29 @@ description: "# ActiveGenie \U0001F9DE‍♂️\n> Transform your Ruby applicati
   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### 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### Elo ranking (WIP)\nThe Elo ranking is a
-  tool that can be used to rank a set of items. It uses a set of rules to rank the
-  items out of the box. Uses the best practices of prompt engineering and engineering
-  to make the ranking as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\nitems
-  = ['Square', 'Circle', 'Triangle']\ncriterias = 'items that look rounded'\nranked_items
-  = ActiveGenie::EloRanking.call(items, criterias, rounds: 10)\nputs ranked_items
-  # => [{ name: \"Circle\", score: 1500 }, { name: \"Square\", score: 800 }, { name:
-  \"Triangle\", score: 800 }]\n```\n\n\n## Configuration Options\n\n| Option | 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 options, 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\n"
+  and detailed interface documentation.\n\n### Data Ranking\nThe Ranking 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::Ranking.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-
+  **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 [Ranking README](lib/active_genie/ranking/README.md) for implementation details,
+  configuration, and advanced ranking strategies.\n\n### Text Summarizer (Future)\n###
+  Language detector (Future)\n### Translator (Future)\n### Sentiment analyzer (Future)\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: []
@@ -121,26 +100,31 @@ files:
 - lib/active_genie/battle.rb
 - lib/active_genie/battle/README.md
 - lib/active_genie/battle/basic.rb
-- lib/active_genie/clients/openai.rb
-- lib/active_genie/clients/router.rb
+- lib/active_genie/clients/openai_client.rb
+- lib/active_genie/clients/unified_client.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_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/leaderboard.rb
-- lib/active_genie/leaderboard/elo_ranking.rb
-- lib/active_genie/leaderboard/leaderboard.rb
-- lib/active_genie/leaderboard/league.rb
-- lib/active_genie/leaderboard/player.rb
-- lib/active_genie/leaderboard/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/utils/math.rb
+- lib/active_genie/scoring/recommended_reviewers.rb
 - lib/tasks/install.rake
-- lib/tasks/templates/active_genie.yml
+- lib/tasks/templates/active_genie.rb
 homepage: https://github.com/Roriz/active_genie
 licenses:
 - Apache-2.0

data/lib/active_genie/clients/openai.rb

@@ -1,61 +0,0 @@
-require 'json'
-require 'net/http'
-
-module ActiveGenie::Clients
-  class Openai
-    class << self
-      def function_calling(messages, function, options: {})
-        app_config = ActiveGenie.config_by_model(options[:model])
-
-        model = options[:model] || app_config[:model]
-        
-        raise "Model can't be blank" if model.nil?
-
-        payload = {
-          messages:,
-          response_format: {
-            type: 'json_schema',
-            json_schema: function
-          },
-          model:,
-        }
-
-        api_key = options[:api_key] || app_config[:api_key]
-
-        headers = DEFAULT_HEADERS.merge(
-          'Authorization': "Bearer #{api_key}"
-        ).compact
-
-        response = request(payload, headers)
-
-        parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'content'))
-        
-        parsed_response.dig('properties') || parsed_response
-      rescue JSON::ParserError
-        nil
-      end
-
-      def request(payload, headers)
-        response = Net::HTTP.post(
-          URI(API_URL),
-          payload.to_json,
-          headers
-        )
-
-        raise OpenaiError, response.body unless response.is_a?(Net::HTTPSuccess)
-        return nil if response.body.empty?
-
-        JSON.parse(response.body)
-      end
-
-    end
-    
-    API_URL = 'https://api.openai.com/v1/chat/completions'.freeze
-    DEFAULT_HEADERS = {
-      'Content-Type': 'application/json',
-    }
-
-    # TODO: add some more rich error handling
-    class OpenaiError < StandardError; end
-  end
-end

data/lib/active_genie/clients/router.rb

@@ -1,41 +0,0 @@
-require_relative './openai'
-
-module ActiveGenie::Clients
-  class Router
-    class << self
-      def function_calling(messages, function, options: {})
-        app_config = ActiveGenie.config_by_model(options[:model])
-
-        provider = options[:provider] || app_config[:provider]
-        client = PROVIDER_TO_CLIENT[provider&.downcase&.strip&.to_sym]
-        raise "Provider \"#{provider}\" not supported" unless client
-
-        response = client.function_calling(messages, function, options:)
-
-        clear_invalid_values(response)
-      end
-
-      private
-
-      PROVIDER_TO_CLIENT = {
-        openai: Openai,
-      }
-
-      INVALID_VALUES = [
-        'not sure',
-        'not clear',
-        'not specified',
-        'none',
-        'null',
-        'undefined',
-      ].freeze
-
-      def clear_invalid_values(data)
-        data.reduce({}) do |acc, (field, value)|
-          acc[field] = value unless INVALID_VALUES.include?(value)
-          acc
-        end
-      end
-    end
-  end
-end

data/lib/active_genie/leaderboard/elo_ranking.rb

@@ -1,88 +0,0 @@
-require_relative '../battle/basic'
-require_relative '../utils/math'
-
-module ActiveGenie::Leaderboard
-  class EloRanking
-    def self.call(players, criteria, options: {})
-      new(players, criteria, options:).call
-    end
-
-    def initialize(players, criteria, options: {})
-      @players = players
-      @criteria = criteria
-      @options = options
-    end
-
-    def call
-      @players.each(&:generate_elo_by_score)
-
-      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)
-        end
-
-        @players.tier_relegation.each { |player| player.eliminated = "relegation/#{@players.eligible_size}" }
-      end
-
-      @players
-    end
-
-    private
-
-    MATCHS_PER_PLAYER = 3
-    LOSE_PENALTY = 15
-    MINIMAL_PLAYERS_TO_BATTLE = 10
-
-    # 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,
-        options: @options
-      ).values_at('winner', 'loser')
-    end
-
-    def update_elo(winner, loser)
-      return if winner.nil? || loser.nil?
-
-      new_winner_elo, new_loser_elo = ActiveGenie::Utils::Math.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
-  end
-end

data/lib/active_genie/leaderboard/leaderboard.rb

@@ -1,72 +0,0 @@
-require_relative './players_collection'
-require_relative './league'
-require_relative './elo_ranking'
-require_relative '../scoring/recommended_reviews'
-
-module ActiveGenie::Leaderboard
-  class Leaderboard
-    def self.call(param_players, criteria, options: {})
-      new(param_players, criteria, options:).call
-    end
-
-    def initialize(param_players, criteria, options: {})
-      @param_players = param_players
-      @criteria = criteria
-      @options = options
-    end
-
-    def call
-      set_initial_score_players
-      eliminate_obvious_bad_players
-      run_elo_ranking if players.eligible_size > 10
-      run_league
-
-      players.to_h
-    end
-
-    private
-
-    SCORE_VARIATION_THRESHOLD = 10
-    MATCHS_PER_PLAYER = 3
-
-    def set_initial_score_players
-      players.each do |player|
-        player.score = generate_score(player.content) # This can take a while, can be parallelized
-      end
-    end
-
-    def generate_score(content)
-      ActiveGenie::Scoring::Basic.call(content, @criteria, reviewers, options: @options)['final_score']
-    end
-
-    def eliminate_obvious_bad_players
-      while players.coefficient_of_variation >= SCORE_VARIATION_THRESHOLD
-        players.eligible.last.eliminated = 'too_low_score'
-      end
-    end
-
-    def run_elo_ranking
-      EloRanking.call(players, @criteria, options: @options)
-    end
-
-    def run_league
-      League.call(players, @criteria, options: @options)
-    end
-
-    def reviewers
-      [recommended_reviews['reviewer1'], recommended_reviews['reviewer2'], recommended_reviews['reviewer3']]
-    end
-
-    def recommended_reviews
-      @recommended_reviews ||= ActiveGenie::Scoring::RecommendedReviews.call(
-        players.sample,
-        @criteria,
-        options: @options
-      )
-    end
-
-    def players
-      @players ||= PlayersCollection.new(@param_players)
-    end
-  end
-end

data/lib/active_genie/leaderboard/league.rb

@@ -1,48 +0,0 @@
-require_relative '../battle/basic'
-
-module ActiveGenie::Leaderboard
-  class League
-    def self.call(players, criteria, options: {})
-      new(players, criteria, options:).call
-    end
-
-    def initialize(players, criteria, options: {})
-      @players = players
-      @criteria = criteria
-      @options = options
-    end
-
-    def call
-      matches.each do |player_a, player_b|
-        winner, loser = battle(player_a, player_b)
-
-        if winner.nil? || loser.nil?
-          player_a.league[:draw] += 1
-          player_b.league[:draw] += 1
-        else
-          winner.league[:win] += 1
-          loser.league[:lose] += 1
-        end
-      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)
-      ActiveGenie::Battle.basic(
-        player_a,
-        player_b,
-        @criteria,
-        options: @options
-      ).values_at('winner', 'loser')
-    end
-  end
-end

data/lib/active_genie/leaderboard/player.rb

@@ -1,52 +0,0 @@
-require 'securerandom'
-
-module ActiveGenie::Leaderboard
-  class Player
-    def initialize(params)
-      params = { content: params } if params.is_a?(String)
-
-      @id = params.dig(:id) || SecureRandom.uuid
-      @content = params.dig(:content) || params
-      @score = params.dig(:score) || nil
-      @elo = params.dig(:elo) || nil
-      @league = {
-        win: params.dig(:league, :win) || 0,
-        lose: params.dig(:league, :lose) || 0,
-        draw: params.dig(:league, :draw) || 0
-      }
-      @eliminated = params.dig(:eliminated) || nil
-    end
-
-    attr_reader :id, :content, :score, :elo, :league, :eliminated
-
-    def generate_elo_by_score
-      return if !@elo.nil? || @score.nil?
-
-      @elo = BASE_ELO + (@score - 50)
-    end
-
-    def score=(value)
-      @score = value
-    end
-
-    def elo=(value)
-      @elo = value
-    end
-
-    def eliminated=(value)
-      @eliminated = value
-    end
-
-    def league_score
-      @league[:win] * 3 + @league[:draw]
-    end
-
-    def to_h
-      { id:, content:, score:, elo:, eliminated:, league: }
-    end
-
-    private
-    
-    BASE_ELO = 1000
-  end
-end

data/lib/active_genie/leaderboard.rb

@@ -1,11 +0,0 @@
-require_relative 'leaderboard/leaderboard'
-
-module ActiveGenie
-  module Leaderboard
-    module_function
-
-    def call(...)
-      Leaderboard.call(...)
-    end
-  end
-end

data/lib/active_genie/utils/math.rb

@@ -1,15 +0,0 @@
-module ActiveGenie::Utils
-  module Math
-    module_function
-
-    def self.calculate_new_elo(winner, loser, k: 32)
-      expected_score_a = 1 / (1 + 10**((loser - winner) / 400))
-      expected_score_b = 1 - expected_score_a
-
-      new_elo_winner = winner + k * (1 - expected_score_a)
-      new_elo_loser = loser + k * (1 - expected_score_b)
-
-      [new_elo_winner, new_elo_loser]
-    end
-  end
-end

data/lib/tasks/templates/active_genie.yml

@@ -1,7 +0,0 @@
-# gpt-4o-mini:
-#   api_key: <%= ENV['OPENAI_API_KEY'] %>
-#   provider: 'openai'
-# 
-# claude-3-5-sonnet:
-#  api_key: <%= ENV['ANTHROPIC_API_KEY'] %>
-#  provider: 'anthropic'