active_genie 0.0.24 → 0.0.25

data/lib/active_genie/data_extractor/README.md

@@ -17,24 +17,24 @@ schema = {
   age: { type: 'integer', description: 'Age in years' }
 }
 result = ActiveGenie::DataExtractor.call(text, schema)
-# => { 
-#      name: "John Doe", 
+# => {
+#      name: "John Doe",
 #      name_explanation: "Found directly in text",
-#      age: 25, 
-#      age_explanation: "Explicitly stated as 25 years old" 
+#      age: 25,
+#      age_explanation: "Explicitly stated as 25 years old"
 #    }
 
 product = "Nike Air Max 90 - Size 42 - $199.99"
 schema = {
-  brand: { 
+  brand: {
     type: 'string',
     enum: ["Nike", "Adidas", "Puma"]
   },
-  price: { 
+  price: {
     type: 'number',
     minimum: 0
   },
-  currency: { 
+  currency: {
     type: 'string',
     enum: ["USD", "EUR"]
   },
@@ -46,8 +46,8 @@ schema = {
 }
 
 result = ActiveGenie::DataExtractor.call(product, schema)
-# => { 
-#      brand: "Nike", 
+# => {
+#      brand: "Nike",
 #      brand_explanation: "Brand name found at start of text",
 #      price: 199.99,
 #      price_explanation: "Price found in USD format at end",
@@ -70,12 +70,12 @@ The `from_informal` method extends the basic extraction by analyzing rhetorical
 
 ```ruby
 text = "The weather isn't bad today"
-schema = { 
-  mood: { type: 'string', description: 'The mood of the message' } 
+schema = {
+  mood: { type: 'string', description: 'The mood of the message' }
 }
 
 result = ActiveGenie::DataExtractor.from_informal(text, schema)
-# => { 
+# => {
 #      mood: "positive",
 #      mood_explanation: "Speaker views weather favorably",
 #      message_litote: true,
@@ -117,7 +117,7 @@ Extracts structured data from text based on a predefined schema.
 - Additional analysis fields when using `from_informal`
 
 ### `.from_informal(text, data_to_extract, config = {})`
-Extends basic extraction with rhetorical analysis, particularly for litotes.
+Extends  extraction with rhetorical analysis, particularly for litotes.
 
 #### Additional Return Fields
 | Name | Type | Description |

data/lib/active_genie/data_extractor/from_informal.rb

@@ -1,58 +1,64 @@
-module ActiveGenie::DataExtractor
-  class FromInformal
-    def self.call(...)
-      new(...).call()
-    end
+# frozen_string_literal: true
 
-    # Extracts data from informal text while also detecting litotes and their meanings.
-    # This method extends the basic extraction by analyzing rhetorical devices.
-    #
-    # @param text [String] The informal text to analyze
-    # @param data_to_extract [Hash] Schema defining the data structure to extract
-    # @param config [Hash] Additional config for the extraction process
-    #
-    # @return [Hash] The extracted data including litote analysis. In addition to the
-    #   schema-defined fields, includes:
-    #   - message_litote: Whether the text contains a litote
-    #   - litote_rephrased: The positive rephrasing of any detected litote
-    #
-    # @example Analyze text with litote
-    #   text = "The weather isn't bad today"
-    #   schema = { mood: { type: 'string', description: 'The mood of the message' } }
-    #   DataExtractor.from_informal(text, schema)
-    #   # => { mood: "positive", mood_explanation: "Speaker views weather favorably",
-    #   #      message_litote: true,
-    #   #      litote_rephrased: "The weather is good today" }
-    def initialize(text, data_to_extract, config: {})
-      @text = text
-      @data_to_extract = data_to_extract
-      @config = ActiveGenie::Configuration.to_h(config)
-    end
+require_relative 'generalist'
 
-    def call
-      response = Basic.call(@text, data_to_extract_with_litote, config: @config)
+module ActiveGenie
+  module DataExtractor
+    class FromInformal
+      def self.call(...)
+        new(...).call
+      end
 
-      if response['message_litote']
-        response = Basic.call(response['litote_rephrased'], @data_to_extract, config: @config)
+      # Extracts data from informal text while also detecting litotes and their meanings.
+      # This method extends the basic extraction by analyzing rhetorical devices.
+      #
+      # @param text [String] The informal text to analyze
+      # @param data_to_extract [Hash] Schema defining the data structure to extract
+      # @param config [Hash] Additional config for the extraction process
+      #
+      # @return [Hash] The extracted data including litote analysis. In addition to the
+      #   schema-defined fields, includes:
+      #   - message_litote: Whether the text contains a litote
+      #   - litote_rephrased: The positive rephrasing of any detected litote
+      #
+      # @example Analyze text with litote
+      #   text = "The weather isn't bad today"
+      #   schema = { mood: { type: 'string', description: 'The mood of the message' } }
+      #   DataExtractor.from_informal(text, schema)
+      #   # => { mood: "positive", mood_explanation: "Speaker views weather favorably",
+      #   #      message_litote: true,
+      #   #      litote_rephrased: "The weather is good today" }
+      def initialize(text, data_to_extract, config: {})
+        @text = text
+        @data_to_extract = data_to_extract
+        @config = ActiveGenie.configuration.merge(config)
       end
 
-      response
-    end
+      def call
+        response = Generalist.call(@text, data_to_extract_with_litote, config: @config)
+
+        if response['message_litote']
+          response = Generalist.call(response['litote_rephrased'], @data_to_extract, config: @config)
+        end
 
-    private
-
-    def data_to_extract_with_litote
-      {
-        **@data_to_extract,
-        message_litote: {
-          type: 'boolean',
-          description: 'Return true if the message is a litote. A litote is a figure of speech that uses understatement to emphasize a point by stating a negative to further affirm a positive, often incorporating double negatives for effect.'
-        },
-        litote_rephrased: {
-          type: 'string',
-          description: 'The true meaning of the litote. Rephrase the message to a positive and active statement.'
+        response
+      end
+
+      private
+
+      def data_to_extract_with_litote
+        {
+          **@data_to_extract,
+          message_litote: {
+            type: 'boolean',
+            description: 'Return true if the message is a litote. A litote is a figure of speech that uses understatement to emphasize a point by stating a negative to further affirm a positive, often incorporating double negatives for effect.'
+          },
+          litote_rephrased: {
+            type: 'string',
+            description: 'The true meaning of the litote. Rephrase the message to a positive and active statement.'
+          }
         }
-      }
+      end
     end
   end
 end

data/lib/active_genie/data_extractor/generalist.md

@@ -0,0 +1,12 @@
+Extract structured and typed data from user messages.
+Identify relevant information within user messages and categorize it into predefined data fields with specific data types.
+
+# Steps
+1. **Identify Data Types**: Determine the types of data to collect, such as names, dates, email addresses, phone numbers, etc.
+2. **Extract Information**: Use pattern recognition and language understanding to identify and extract the relevant pieces of data from the user message.
+3. **Categorize Data**: Assign the extracted data to the appropriate predefined fields.
+
+# Notes
+- Handle missing or partial information gracefully.
+- Manage multiple occurrences of similar data points by prioritizing the first one unless specified otherwise.
+- Be flexible to handle variations in data format and language clues.

data/lib/active_genie/data_extractor/generalist.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative '../clients/unified_client'
+
+module ActiveGenie
+  module DataExtractor
+    class Generalist
+      def self.call(...)
+        new(...).call
+      end
+
+      # Extracts structured data from text based on a predefined schema.
+      #
+      # @param text [String] The input text to analyze and extract data from
+      # @param data_to_extract [Hash] Schema defining the data structure to extract.
+      #   Each key in the hash represents a field to extract, and its value defines the expected type and constraints.
+      # @param config [Hash] Additional config for the extraction process
+      #
+      # @return [Hash] The extracted data matching the schema structure. Each field will include
+      #   both the extracted value and an explanation of how it was derived.
+      #
+      # @example Extract a person's details
+      #   schema = {
+      #     name: { type: 'string', description: 'Full name of the person' },
+      #     age: { type: 'integer', description: 'Age in years' }
+      #   }
+      #   text = "John Doe is 25 years old"
+      #   DataExtractor.call(text, schema)
+      #   # => { name: "John Doe", name_explanation: "Found directly in text",
+      #   #      age: 25, age_explanation: "Explicitly stated as 25 years old" }
+      def initialize(text, data_to_extract, config: {})
+        @text = text
+        @data_to_extract = data_to_extract
+        @config = ActiveGenie.configuration.merge(config)
+      end
+
+      def call
+        messages = [
+          {  role: 'system', content: prompt },
+          {  role: 'user', content: @text }
+        ]
+
+        properties = data_to_extract_with_explanation
+
+        function = {
+          name: 'data_extractor',
+          description: 'Extract structured and typed data from text',
+          parameters: {
+            type: 'object',
+            properties:,
+            required: properties.keys
+          }
+        }
+
+        response = function_calling(messages, function)
+
+        simplify_response(response)
+      end
+
+      private
+
+      def data_to_extract_with_explanation
+        return @data_to_extract unless @config.data_extractor.with_explanation
+
+        with_explanation = {}
+
+        @data_to_extract.each do |key, value|
+          with_explanation[key] = value
+          with_explanation["#{key}_explanation"] = {
+            type: 'string',
+            description: "The chain of thought that led to the conclusion about: #{key}. Can be blank if the user didn't provide any context"
+          }
+          with_explanation["#{key}_accuracy"] = {
+            type: 'integer',
+            description: 'The accuracy of the extracted data, what is the percentage of confidence? When 100 it means the data is explicitly stated in the text. When 0 it means is no way to discover the data from the text'
+          }
+        end
+
+        with_explanation
+      end
+
+      def function_calling(messages, function)
+        response = ::ActiveGenie::Clients::UnifiedClient.function_calling(
+          messages,
+          function,
+          config: @config
+        )
+
+        ActiveGenie::Logger.call(
+          {
+            code: :data_extractor,
+            text: @text[0..30],
+            data_to_extract: function[:parameters][:properties],
+            extracted_data: response
+          }
+        )
+
+        response
+      end
+
+      def simplify_response(response)
+        return response if @config.data_extractor.verbose
+
+        simplified_response = {}
+
+        @data_to_extract.each_key do |key|
+          next if !response.key?(key)
+          next if response.key?("#{key}_accuracy") && response["#{key}_accuracy"] < min_accuracy
+
+          simplified_response[key] = response[key]
+        end
+
+        simplified_response
+      end
+
+      def min_accuracy
+        @config.data_extractor.min_accuracy # default 70
+      end
+
+      def prompt
+        File.read(File.join(__dir__, 'generalist.md'))
+      end
+    end
+  end
+end

data/lib/active_genie/data_extractor.rb

@@ -1,4 +1,6 @@
-require_relative 'data_extractor/basic'
+# frozen_string_literal: true
+
+require_relative 'data_extractor/generalist'
 require_relative 'data_extractor/from_informal'
 
 module ActiveGenie
@@ -6,12 +8,12 @@ module ActiveGenie
   module DataExtractor
     module_function
 
-    def basic(...)
-      Basic.call(...)
+    def call(...)
+      Generalist.call(...)
     end
 
-    def call(...)
-      Basic.call(...)
+    def generalist(...)
+      Generalist.call(...)
     end
 
     def from_informal(...)

data/lib/active_genie/errors/invalid_provider_error.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  class InvalidProviderError < StandardError
+    TEXT = <<~TEXT
+      Invalid provider: %<provider>s
+
+      To configure ActiveGenie, you can either:
+      1. Set up global configuration:
+         ```ruby
+         ActiveGenie.configure do |config|
+           config.provider = 'your_provider'
+           config.api_key = 'your_api_key'
+           # ... other configuration options
+         end
+         ```
+
+      2. Or pass configuration directly to the method call:
+         ```ruby
+         ActiveGenie::DataExtraction.call(
+           arg1,
+           arg2,
+           config: {
+             provider: 'your_provider',
+             api_key: 'your_api_key'
+           }
+         )
+         ```
+
+      Available providers: %<available_providers>s
+    TEXT
+
+    def initialize(provider)
+      super(format(TEXT, provider:, available_providers:))
+    end
+
+    def available_providers
+      ActiveGenie.configuration.providers.all.keys.join(', ')
+    end
+  end
+end

data/lib/active_genie/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'fileutils'
 
@@ -5,87 +7,36 @@ module ActiveGenie
   module Logger
     module_function
 
-    def with_context(context, observer: nil)
-      @context ||= {}
-      @observers ||= []
-      begin
-        @context = @context.merge(context)
-        @observers << observer if observer
-        yield if block_given?
-      ensure
-        @context.delete_if { |key, _| context.key?(key) }
-        @observers.delete(observer)
-      end
-    end
-
-    def info(log)
-      call(log, level: :info)
-    end
-
-    def error(log)
-      call(log, level: :error)
-    end
-
-    def warn(log)
-      call(log, level: :warn)
-    end
-
-    def debug(log)
-      call(log, level: :debug)
-    end
-
-    def trace(log)
-      call(log, level: :trace)
-    end
-
-    def call(data, level: :info)
+    def call(data)
       log = {
         **(@context || {}),
         **(data || {}),
         timestamp: Time.now,
-        level: level.to_s.upcase,
         process_id: Process.pid
       }
 
-      append_to_file(log)
-      output(log, level)
-      call_observers(log)
+      persist!(log)
+      $stdout.puts log
+      ActiveGenie.configuration.log.call_observers(log)
 
       log
     end
 
-    # Log Levels
-    # 
-    # LOG_LEVELS defines different levels of logging within the application. 
-    # Each level serves a specific purpose, balancing verbosity and relevance.
-    # 
-    # - :info  -> General log messages providing an overview of application behavior, ensuring readability without excessive detail.
-    # - :warn  -> Indicates unexpected behaviors that do not halt execution but require attention, such as retries, timeouts, or necessary conversions.
-    # - :error -> Represents critical errors that prevent the application from functioning correctly.
-    # - :debug -> Provides detailed logs for debugging, offering the necessary context for audits but with slightly less detail than trace logs.
-    # - :trace -> Logs every external call with the highest level of detail, primarily for auditing or state-saving purposes. These logs do not provide context regarding triggers or reasons.
-    LOG_LEVELS = { info: 0, error: 0, warn: 1, debug: 2, trace: 3 }.freeze
-
-    attr_accessor :context
-    
-    def append_to_file(log)
-      FileUtils.mkdir_p('logs')
-      File.write('logs/active_genie.log', "#{JSON.generate(log)}\n", mode: 'a')
-    end
-
-    def output(log, level)
-      config_log_level = LOG_LEVELS[log.dig(:config, :log_level)] || LOG_LEVELS[:info]
-      if config_log_level >= LOG_LEVELS[level]
-        $stdout.puts log
-      else
-        $stdout.print '.'
+    def with_context(context)
+      @context ||= {}
+      begin
+        @context = @context.merge(context)
+        yield if block_given?
+      ensure
+        @context.delete_if { |key, _| context.key?(key) }
       end
     end
 
-    def call_observers(log)
-      return if @observers.nil? || @observers.size.zero?
+    attr_accessor :context
 
-      @observers.each { |observer| observer.call(log) }
+    def persist!(log)
+      FileUtils.mkdir_p('log')
+      File.write('log/active_genie.log', "#{JSON.generate(log)}\n", mode: 'a')
     end
   end
 end

data/lib/active_genie/ranking/README.md

@@ -40,4 +40,34 @@ The method processes the players through scoring, elimination, and ranking phase
 - Adjust initial criteria to ensure consistency
 - Adjust each player's content to ensure consistency
 - Support players with images or audio
-- Parallelize processing battles and scoring
+- Parallelize processing battles and scoring
+
+## Ranking Configuration
+
+| Config | Description | Default |
+|--------|-------------|---------|
+| `score_variation_threshold` | Threshold for eliminating players with inconsistent scores | `30` |
+
+## Ranking Callbacks
+Callbacks are optional and can be used to watch any changes in players, battles, or scoring.
+
+| Callback | Description |
+|--------|-------------|
+| `watch_players` | Callback to watch any changes in players |
+| `watch_battles` | Callback to watch any changes in battles |
+| `watch_scoring` | Callback to watch any changes in scoring |
+
+Example of callback usage:
+
+```ruby
+result = ActiveGenie::Ranking.call(
+  players,
+  criteria,
+  config: {
+    watch_players: ->(player) { puts player },
+    watch_battles: ->(battle) { puts battle },
+    watch_scoring: ->(scoring) { puts scoring }
+  }
+)
+```
+