active_genie 0.29.0 → 0.30.0

data/lib/active_genie/ranking/players_collection.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'player'
-
-module ActiveGenie
-  module Ranking
-    class PlayersCollection
-      def initialize(param_players)
-        @players = build(param_players)
-      end
-      attr_reader :players
-
-      def coefficient_of_variation
-        mean = score_mean
-
-        return nil if mean.zero?
-
-        variance = all_scores.map { |num| (num - mean)**2 }.sum / all_scores.size
-        standard_deviation = Math.sqrt(variance)
-
-        (standard_deviation / mean) * 100
-      end
-
-      def all_scores
-        eligible.map(&:score).compact
-      end
-
-      def score_mean
-        return 0 if all_scores.empty?
-
-        all_scores.sum.to_f / all_scores.size
-      end
-
-      def calc_relegation_tier
-        eligible[(tier_size * -1)..]
-      end
-
-      def calc_defender_tier
-        eligible[(tier_size * -2)...(tier_size * -1)]
-      end
-
-      def eligible
-        sorted.reject(&:eliminated)
-      end
-
-      def eligible_size
-        @players.reject(&:eliminated).size
-      end
-
-      def elo_eligible?
-        eligible.size > 15
-      end
-
-      def sorted
-        @players.sort_by { |p| -p.sort_value }
-      end
-
-      def to_json(*_args)
-        @players.map(&:to_h).to_json
-      end
-
-      def method_missing(...)
-        @players.send(...)
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        @players.respond_to?(method_name, include_private)
-      end
-
-      private
-
-      def build(param_players)
-        param_players.map { |p| Player.new(p) }
-      end
-
-      # Returns the number of players to battle in each round
-      # based on the eligible size, start fast and go slow until top 10
-      # Example:
-      #   - 50 eligible, tier_size: 15
-      #   - 35 eligible, tier_size: 11
-      #   - 24 eligible, tier_size: 10
-      #   - 14 eligible, tier_size: 4
-      #  4 rounds to reach top 10 with 50 players
-      def tier_size
-        size = (eligible_size / 3).ceil
-
-        if eligible_size < 10
-          (eligible_size / 2).ceil
-        else
-          size.clamp(10, eligible_size - 10)
-        end
-      end
-    end
-  end
-end

data/lib/active_genie/ranking/ranking_scoring.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveGenie
-  module Ranking
-    class RankingScoring
-      def self.call(...)
-        new(...).call
-      end
-
-      def initialize(players, criteria, reviewers: [], config: nil)
-        @players = players
-        @criteria = criteria
-        @config = ActiveGenie.configuration.merge(config)
-        @reviewers = Array(reviewers).compact.uniq
-      end
-
-      def call
-        @config.log.additional_context = { ranking_scoring_id: }
-        @reviewers = generate_reviewers
-
-        players_without_score.each do |player|
-          player.score = generate_score(player)
-        end
-      end
-
-      private
-
-      def players_without_score
-        @players_without_score ||= @players.select { |player| player.score.nil? }
-      end
-
-      def generate_score(player)
-        score, reasoning = ActiveGenie::Scoring.call(
-          player.content,
-          @criteria,
-          @reviewers,
-          config: @config
-        ).values_at('final_score', 'final_reasoning')
-
-        @config.logger.call({ code: :new_score, player_id: player.id, score:, reasoning: })
-
-        score
-      end
-
-      def generate_reviewers
-        return @reviewers if @reviewers.size.positive?
-
-        reviewer1, reviewer2, reviewer3 = ActiveGenie::Scoring::RecommendedReviewers.call(
-          [@players.sample.content, @players.sample.content].join("\n\n"),
-          @criteria,
-          config: @config
-        ).values_at('reviewer1', 'reviewer2', 'reviewer3')
-
-        @config.logger.call({ code: :new_reviewers, reviewers: [reviewer1, reviewer2, reviewer3] })
-
-        [reviewer1, reviewer2, reviewer3]
-      end
-
-      def ranking_scoring_id
-        @ranking_scoring_id ||= begin
-          player_ids = players_without_score.map(&:id).join(',')
-          ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
-
-          "#{Digest::MD5.hexdigest(ranking_unique_key)}-scoring"
-        end
-      end
-    end
-  end
-end

data/lib/active_genie/ranking.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'ranking/ranking'
-
-module ActiveGenie
-  # See the [ranking README](lib/active_genie/ranking/README.md) for more information.
-  module Ranking
-    module_function
-
-    def call(...)
-      Ranking.call(...)
-    end
-  end
-end

data/lib/active_genie/scoring/generalist.json

@@ -1,9 +0,0 @@
-{
-  "name": "scoring",
-  "description": "Score the text based on the given criteria.",
-  "parameters": {
-    "type": "object",
-    "properties": {},
-    "required": {}
-  }
-}

data/lib/active_genie/scoring/generalist.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../clients/unified_client'
-
-module ActiveGenie
-  module Scoring
-    # The Generalist class provides a foundation for scoring text content against specified criteria
-    # using AI-powered evaluation. It supports both single and multiple reviewer scenarios,
-    # with the ability to automatically recommend reviewers when none are specified.
-    #
-    # The scoring process evaluates text based on given criteria and returns detailed feedback
-    # including individual reviewer scores, reasoning, and a final aggregated score.
-    #
-    # @example Generalist usage with a single reviewer
-    #   Generalist.call("Sample text", "Evaluate grammar and clarity", ["Grammar Expert"])
-    #
-    # @example Usage with automatic reviewer recommendation
-    #   Generalist.call("Sample text", "Evaluate technical accuracy")
-    #
-    class Generalist
-      # @param text [String] The text content to be evaluated
-      # @param criteria [String] The evaluation criteria or rubric to assess against
-      # @param reviewers [Array<String>] Optional list of specific reviewers. If empty,
-      #   reviewers will be automatically recommended based on the content and criteria
-      # @param config [Hash] Additional configuration config that modify the scoring behavior
-      # @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 reviewers
-      #   @return [String] :final_reasoning Detailed explanation of why the final score was reached
-      def self.call(...)
-        new(...).call
-      end
-
-      def initialize(text, criteria, reviewers = [], config: {})
-        @text = text
-        @criteria = criteria
-        @param_reviewers = Array(reviewers).compact.uniq
-        @config = ActiveGenie.configuration.merge(config)
-      end
-
-      def call
-        messages = [
-          {  role: 'system', content: PROMPT },
-          {  role: 'user', content: "Scoring criteria: #{@criteria}" },
-          {  role: 'user', content: "Text to score: #{@text}" }
-        ]
-
-        result = ::ActiveGenie::Clients::UnifiedClient.function_calling(
-          messages,
-          build_function,
-          config: @config
-        )
-
-        result['final_score'] = 0 if result['final_score'].nil?
-
-        @config.logger.call({
-                              code: :scoring,
-                              text: @text[0..30],
-                              criteria: @criteria[0..30],
-                              reviewers: reviewers,
-                              score: result['final_score'],
-                              reasoning: result['final_reasoning']
-                            })
-
-        result
-      end
-
-      PROMPT = File.read(File.join(__dir__, 'generalist.prompt.md'))
-
-      private
-
-      def build_function
-        properties = build_properties
-
-        function = JSON.parse(File.read(File.join(__dir__, 'generalist.json')), symbolize_names: true)
-        function[:parameters][:properties] = properties
-        function[:parameters][:required] = properties.keys
-
-        function
-      end
-
-      def build_properties
-        properties = {}
-        reviewers.each do |reviewer|
-          properties["#{reviewer}_reasoning"] = {
-            type: 'string',
-            description: "The reasoning of the scoring process by #{reviewer}."
-          }
-          properties["#{reviewer}_score"] = {
-            type: 'number',
-            description: "The score given by #{reviewer}.",
-            min: 0,
-            max: 100
-          }
-        end
-
-        properties[:final_score] = {
-          type: 'number',
-          description: 'The final score based on the previous reviewers'
-        }
-        properties[:final_reasoning] = {
-          type: 'string',
-          description: 'The final reasoning based on the previous reviewers'
-        }
-
-        properties
-      end
-
-      def reviewers
-        @reviewers ||= if @param_reviewers.any?
-                         @param_reviewers
-                       else
-                         result = RecommendedReviewers.call(@text, @criteria, config: @config)
-
-                         [result['reviewer1'], result['reviewer2'], result['reviewer3']]
-                       end
-      end
-    end
-  end
-end

data/lib/active_genie/scoring/recommended_reviewers.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../clients/unified_client'
-
-module ActiveGenie
-  module Scoring
-    # The RecommendedReviewers class intelligently suggests appropriate reviewer roles
-    # for evaluating text content based on specific criteria. It uses AI to analyze
-    # the content and criteria to identify the most suitable subject matter experts.
-    #
-    # The class ensures a balanced and comprehensive review process by recommending
-    # three distinct reviewer roles with complementary expertise and perspectives.
-    #
-    # @example Getting recommended reviewers for technical content
-    #   RecommendedReviewers.call("Technical documentation about API design",
-    #                           "Evaluate technical accuracy and clarity")
-    #   # => { reviewer1: "API Architect", reviewer2: "Technical Writer",
-    #   #      reviewer3: "Developer Advocate", reasoning: "..." }
-    #
-    class RecommendedReviewers
-      def self.call(...)
-        new(...).call
-      end
-
-      # Initializes a new reviewer recommendation instance
-      #
-      # @param text [String] The text content to analyze for reviewer recommendations
-      # @param criteria [String] The evaluation criteria that will guide reviewer selection
-      # @param config [Hash] Additional configuration config that modify the recommendation process
-      def initialize(text, criteria, config: {})
-        @text = text
-        @criteria = criteria
-        @config = ActiveGenie.configuration.merge(config)
-      end
-
-      def call
-        messages = [
-          {  role: 'system', content: PROMPT },
-          {  role: 'user', content: "Scoring criteria: #{@criteria}" },
-          {  role: 'user', content: "Text to score: #{@text}" }
-        ]
-
-        function = {
-          name: 'identify_reviewers',
-          description: 'Discover reviewers based on the text and given criteria.',
-          parameters: {
-            type: 'object',
-            properties: {
-              reasoning: { type: 'string' },
-              reviewer1: { type: 'string' },
-              reviewer2: { type: 'string' },
-              reviewer3: { type: 'string' }
-            },
-            required: %w[reasoning reviewer1 reviewer2 reviewer3]
-          }
-        }
-
-        client.function_calling(
-          messages,
-          function,
-          config: @config
-        )
-      end
-
-      PROMPT = <<~PROMPT
-        Identify the top 3 suitable reviewer titles or roles based on the provided text and criteria. Selected reviewers must possess subject matter expertise, offer valuable insights, and ensure diverse yet aligned perspectives on the content.
-
-        # Instructions
-        1. **Analyze the Text and Criteria**: Examine the content and criteria to identify relevant reviewer titles or roles.
-        2. **Determine Subject Matter Expertise**: Select reviewers with substantial knowledge or experience in the subject area.
-        3. **Evaluate Insight Contribution**: Prioritize titles or roles capable of providing meaningful and actionable feedback on the content.
-        4. **Incorporate Perspective Diversity**: Ensure the selection includes reviewers with varied but complementary viewpoints while maintaining alignment with the criteria.
-
-        # Constraints
-        - Selected reviewers must align with the content’s subject matter and criteria.
-        - Include reasoning for how each choice supports a thorough and insightful review.
-        - Avoid redundant or overly similar titles/roles to maintain diversity.
-      PROMPT
-
-      private
-
-      def client
-        ::ActiveGenie::Clients::UnifiedClient
-      end
-    end
-  end
-end

data/lib/active_genie/scoring.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'scoring/generalist'
-require_relative 'scoring/recommended_reviewers'
-
-module ActiveGenie
-  # See the [Scoring README](lib/active_genie/scoring/README.md) for more information.
-  module Scoring
-    module_function
-
-    def call(...)
-      Generalist.call(...)
-    end
-
-    def generalist(...)
-      Generalist.call(...)
-    end
-
-    def recommended_reviewers(...)
-      RecommendedReviewers.call(...)
-    end
-  end
-end