active_genie 0.26.5 → 0.27.1

data/lib/active_genie/data_extractor/README.md

@@ -1,131 +0,0 @@
-# Data Extractor
-Extract structured data from text using AI-powered analysis, handling informal language and complex expressions.
-
-## ✨ Features
-- Structured data extraction - Extract typed data from unstructured text using predefined schemas
-- Informal text analysis - Identifies and handles informal language patterns, including litotes
-- Explanation tracking - Provides reasoning for each extracted data point
-
-## Basic Usage
-
-Extract structured data from text using predefined schemas:
-
-```ruby
-text = "John Doe is 25 years old"
-schema = {
-  name: { type: 'string', description: 'Full name of the person' },
-  age: { type: 'integer', description: 'Age in years' }
-}
-result = ActiveGenie::DataExtractor.call(text, schema)
-# => {
-#      name: "John Doe",
-#      name_explanation: "Found directly in text",
-#      age: 25,
-#      age_explanation: "Explicitly stated as 25 years old"
-#    }
-
-product = "Nike Air Max 90 - Size 42 - $199.99"
-schema = {
-  brand: {
-    type: 'string',
-    enum: ["Nike", "Adidas", "Puma"]
-  },
-  price: {
-    type: 'number',
-    minimum: 0
-  },
-  currency: {
-    type: 'string',
-    enum: ["USD", "EUR"]
-  },
-  size: {
-    type: 'integer',
-    minimum: 35,
-    maximum: 46
-  }
-}
-
-result = ActiveGenie::DataExtractor.call(product, schema)
-# => {
-#      brand: "Nike",
-#      brand_explanation: "Brand name found at start of text",
-#      price: 199.99,
-#      price_explanation: "Price found in USD format at end",
-#      size: 42,
-#      size_explanation: "Size explicitly stated in the middle",
-#      currency: "USD",
-#      currency_explanation: "Derived from $ symbol"
-#    }
-```
-
-## Informal Text Processing
-
-The `from_informal` method extends the basic extraction by analyzing rhetorical devices and informal language patterns like:
-
-- Litotes ("not bad", "isn't terrible")
-- Affirmative expressions ("sure", "no problem")
-- Negative expressions ("nah", "not really")
-
-### Example
-
-```ruby
-text = "The weather isn't bad today"
-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,
-#      litote_rephrased: "The weather is good today"
-#    }
-```
-
-### Usage Notes
-- Best suited for processing conversational user inputs
-- Automatically detects and interprets litotes
-- Provides rephrased positive statements for litotes
-- May require more processing time due to rhetorical analysis
-- Accuracy depends on context clarity
-
-⚠️ Performance Impact: This method performs additional rhetorical analysis, which can increase processing time.
-
-## Interface
-
-### `.call(text, data_to_extract, config = {})`
-Extracts structured data from text based on a predefined schema.
-
-#### Parameters
-| Name | Type | Description | Required | Example |
-| --- | --- | --- | --- | --- |
-| `text` | `String` | The text to analyze and extract data from | Yes | "John Doe is 25 years old" |
-| `data_to_extract` | `Hash` | Schema defining the data structure to extract | Yes | `{ name: { type: 'string' } }` |
-| `config` | `Hash` | Additional extraction configuration | No | `{ model: "gpt-4" }` |
-
-#### config
-| Name | Type | Description |
-| --- | --- | --- |
-| `model` | `String` | The model to use for the extraction |
-| `api_key` | `String` | The API key to use for the extraction |
-
-#### Returns
-`Hash` containing:
-- Extracted values matching the schema structure
-- Explanation field for each extracted value
-- Additional analysis fields when using `from_informal`
-
-### `.from_informal(text, data_to_extract, config = {})`
-Extends  extraction with rhetorical analysis, particularly for litotes.
-
-#### Additional Return Fields
-| Name | Type | Description |
-| --- | --- | --- |
-| `message_litote` | `Boolean` | Whether the text contains a litote |
-| `litote_rephrased` | `String` | Positive rephrasing of any detected litote |
-
-⚠️ Performance Considerations
-- Both methods may require multiple AI model calls
-- Informal processing requires additional rhetorical analysis
-- Consider background processing for production use

data/lib/active_genie/ranking/README.md

@@ -1,73 +0,0 @@
-# Ranking
-
-The `ActiveGenie::Ranking` module organizes players based on scores derived from textual evaluations and then ranks them using a multi-stage process. It leverages the scoring system from the `ActiveGenie::Scoring` module to assign initial scores, and then applies advanced ranking methods to produce a competitive ranking.
-
-## Overview
-
-The ranking system performs the following steps:
-
-1. **Initial Scoring**: Each player’s textual content is evaluated using `ActiveGenie::Scoring`. This produces a `score` based on multiple expert reviews.
-
-2. **Elimination of Poor Performers**: Players whose scores show a high coefficient of variation (indicating inconsistency) are progressively eliminated. This ensures that only competitive candidates continue in the ranking process.
-
-3. **ELO Ranking**: If there are more than 10 eligible players, an ELO-based ranking is applied. Battles between players are simulated via `ActiveGenie::Battle`, and scores are updated using an ELO algorithm tailored to the ranking.
-
-4. **Free for all Matches**: Finally, the remaining players engage in head-to-head matches where each unique pair competes. Match outcomes (wins, losses, draws) are recorded to finalize the rankings.
-
-## Components
-
-- **ranking**: Orchestrates the entire ranking process. Initializes player scores, eliminates outliers, and coordinates ranking rounds.
-
-- **EloRanking**: Applies an ELO-based system to rank players through simulated battles. It updates players’ ELO scores based on match outcomes and predefined rules (including penalties for losses).
-
-- **Free for all**: Conducts complete pairwise matches among eligible players to record win/loss/draw statistics and refine the final standings.
-
-## Usage
-
-Call the ranking using:
-
-```ruby
-result = ActiveGenie::Ranking.call(players, criteria, config: {})
-```
-
-- `players`: A collection of player instances, each containing textual content to be scored.
-- `criteria`: A string defining the evaluation criteria used by the scoring system.
-- `config`: A hash of additional parameters for customization (e.g., model, api_key).
-
-The method processes the players through scoring, elimination, and ranking phases, then returns a hash containing the player statistics and rankings.
-
-## Possible improvements
-- 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
-
-## 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 }
-  }
-)
-```
-

data/lib/active_genie/ranking/concerns/loggable.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveGenie
-  module Concerns
-    module Loggable
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def call_with_log_context(context_method)
-          original_method = instance_method(:call)
-
-          define_method(:call) do |*args, **kwargs, &block|
-            context = send(context_method, *args, **kwargs)
-
-            ActiveGenie::Logger.with_context(context) do
-              original_method.bind(self).call(*args, **kwargs, &block)
-            end
-          end
-        end
-
-        def logger(...)
-          ActiveGenie::Logger.call(...)
-        end
-      end
-    end
-  end
-end

data/lib/active_genie/scoring/README.md

@@ -1,76 +0,0 @@
-# Scoring
-Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers.
-
-## Features
-- Multi-reviewer evaluation - Get scores and feedback from multiple AI-powered expert reviewers
-- Automatic reviewer selection - Smart recommendation of reviewers based on content and criteria
-- Detailed feedback - Comprehensive reasoning for each reviewer's score
-- Customizable weights - Adjust the importance of different reviewers' scores
-- Flexible criteria - Score text against any specified evaluation criteria
-
-## Basic Usage
-
-Score text using predefined reviewers:
-
-```ruby
-text = "The code implements a binary search algorithm with O(log n) complexity"
-criteria = "Evaluate technical accuracy and clarity"
-reviewers = ["Algorithm Expert", "Technical Writer"]
-
-result = ActiveGenie::Scoring.call(text, criteria, reviewers)
-# => {
-#      algorithm_expert_score: 95,
-#      algorithm_expert_reasoning: "Accurately describes binary search and its complexity",
-#      technical_writer_score: 90,
-#      technical_writer_reasoning: "Clear and concise explanation of the algorithm",
-#      final_score: 92.5
-#    }
-```
-
-## Automatic Reviewer Selection
-
-When no reviewers are specified, the system automatically recommends appropriate reviewers:
-
-```ruby
-text = "The patient shows signs of improved cardiac function"
-criteria = "Evaluate medical accuracy and clarity"
-
-result = ActiveGenie::Scoring.call(text, criteria)
-# => {
-#      cardiologist_score: 88,
-#      cardiologist_reasoning: "Accurate assessment of cardiac improvement",
-#      medical_writer_score: 85,
-#      medical_writer_reasoning: "Clear communication of medical findings",
-#      general_practitioner_score: 90,
-#      general_practitioner_reasoning: "Well-structured medical observation",
-#      final_score: 87.7
-#    }
-```
-
-## Interface
-
-### `.call(text, criteria, reviewers = [], config: {})`
-Main interface for scoring text content.
-
-#### Parameters
-- `text` [String] - The text content to be evaluated
-- `criteria` [String] - The evaluation criteria or rubric to assess against
-- `reviewers` [Array<String>] - Optional list of specific reviewers
-- `config` [Hash] - Additional configuration config
-
-### `RecommendedReviewers.call(text, criteria, config: {})`
-Recommends appropriate reviewers based on content and criteria.
-
-#### Parameters
-- `text` [String] - The text content to analyze
-- `criteria` [String] - The evaluation criteria
-- `config` [Hash] - Additional configuration config
-
-### Usage Notes
-- Best suited for objective evaluation of text content
-- Provides balanced scoring through multiple reviewers
-- Automatically handles reviewer selection when needed
-- Supports custom weighting of reviewer scores
-- Returns detailed reasoning for each score
-
-Performance Impact: Using multiple reviewers or requesting detailed feedback may increase processing time.