decision_agent 0.1.3 → 0.1.4

data/lib/decision_agent/ab_testing/ab_testing_agent.rb

@@ -0,0 +1,152 @@
+module DecisionAgent
+  module ABTesting
+    # Agent wrapper that adds A/B testing capabilities to the standard Agent
+    # Automatically handles variant assignment and decision tracking
+    class ABTestingAgent
+      attr_reader :ab_test_manager, :version_manager
+
+      # @param ab_test_manager [ABTestManager] The A/B test manager
+      # @param version_manager [Versioning::VersionManager] Version manager for rules
+      # @param evaluators [Array] Base evaluators (can be overridden by versioned rules)
+      # @param scoring_strategy [Scoring::Base] Scoring strategy
+      # @param audit_adapter [Audit::Adapter] Audit adapter
+      def initialize(
+        ab_test_manager:,
+        version_manager: nil,
+        evaluators: [],
+        scoring_strategy: nil,
+        audit_adapter: nil
+      )
+        @ab_test_manager = ab_test_manager
+        @version_manager = version_manager || ab_test_manager.version_manager
+        @base_evaluators = evaluators
+        @scoring_strategy = scoring_strategy
+        @audit_adapter = audit_adapter
+      end
+
+      # Make a decision with A/B testing support
+      # @param context [Hash, Context] The decision context
+      # @param feedback [Hash] Optional feedback
+      # @param ab_test_id [String, Integer, nil] Optional A/B test ID
+      # @param user_id [String, nil] Optional user ID for consistent assignment
+      # @return [Hash] Decision result with A/B test metadata
+      def decide(context:, feedback: {}, ab_test_id: nil, user_id: nil)
+        ctx = context.is_a?(Context) ? context : Context.new(context)
+
+        # If A/B test is specified, use variant assignment
+        if ab_test_id
+          decide_with_ab_test(ctx, feedback, ab_test_id, user_id)
+        else
+          # Standard decision without A/B testing
+          agent = build_agent(@base_evaluators)
+          decision = agent.decide(context: ctx, feedback: feedback)
+
+          {
+            decision: decision.decision,
+            confidence: decision.confidence,
+            explanations: decision.explanations,
+            evaluations: decision.evaluations,
+            ab_test: nil
+          }
+        end
+      end
+
+      # Get A/B test results
+      # @param test_id [String, Integer] The test ID
+      # @return [Hash] Test results and statistics
+      def get_test_results(test_id)
+        @ab_test_manager.get_results(test_id)
+      end
+
+      # List active A/B tests
+      # @return [Array<ABTest>] Active tests
+      def active_tests
+        @ab_test_manager.active_tests
+      end
+
+      private
+
+      def decide_with_ab_test(context, feedback, ab_test_id, user_id)
+        # Assign variant
+        assignment = @ab_test_manager.assign_variant(test_id: ab_test_id, user_id: user_id)
+
+        # Get the version for the assigned variant
+        version = @version_manager.get_version(version_id: assignment[:version_id])
+        raise VersionNotFoundError, "Version not found: #{assignment[:version_id]}" unless version
+
+        # Build evaluators from the versioned rule content
+        evaluators = build_evaluators_from_version(version)
+
+        # Create agent with version-specific evaluators
+        agent = build_agent(evaluators)
+
+        # Make decision
+        decision = agent.decide(context: context, feedback: feedback)
+
+        # Record the decision result
+        @ab_test_manager.record_decision(
+          assignment_id: assignment[:assignment_id],
+          decision: decision.decision,
+          confidence: decision.confidence
+        )
+
+        # Return decision with A/B test metadata
+        {
+          decision: decision.decision,
+          confidence: decision.confidence,
+          explanations: decision.explanations,
+          evaluations: decision.evaluations,
+          ab_test: {
+            test_id: ab_test_id,
+            variant: assignment[:variant],
+            version_id: assignment[:version_id],
+            assignment_id: assignment[:assignment_id]
+          }
+        }
+      end
+
+      def build_agent(evaluators)
+        Agent.new(
+          evaluators: evaluators.empty? ? @base_evaluators : evaluators,
+          scoring_strategy: @scoring_strategy,
+          audit_adapter: @audit_adapter
+        )
+      end
+
+      def build_evaluators_from_version(version)
+        content = version[:content]
+
+        # If the version content contains evaluator configurations, build them
+        # Otherwise, use base evaluators
+        if content.is_a?(Hash) && content[:evaluators]
+          content[:evaluators].map do |eval_config|
+            build_evaluator_from_config(eval_config)
+          end
+        elsif content.is_a?(Hash) && content[:rules]
+          # Build a JsonRuleEvaluator from the full content (ruleset + rules)
+          [Evaluators::JsonRuleEvaluator.new(rules_json: content)]
+        else
+          # Fallback to base evaluators
+          @base_evaluators
+        end
+      end
+
+      def build_evaluator_from_config(config)
+        case config[:type]
+        when "json_rule"
+          Evaluators::JsonRuleEvaluator.new(
+            rules_json: config[:rules]
+          )
+        when "static"
+          Evaluators::StaticEvaluator.new(
+            decision: config[:decision],
+            weight: config[:weight] || 1.0,
+            reason: config[:reason]
+          )
+        else
+          raise "Unknown evaluator type: #{config[:type]}"
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/ab_testing/storage/activerecord_adapter.rb

@@ -0,0 +1,155 @@
+require "active_record"
+
+module DecisionAgent
+  module ABTesting
+    module Storage
+      # ActiveRecord storage adapter for A/B tests
+      # Requires Rails models: ABTestModel, ABTestAssignmentModel
+      class ActiveRecordAdapter < Adapter
+        # Check if ActiveRecord models are available
+        def self.available?
+          defined?(::ABTestModel) && defined?(::ABTestAssignmentModel)
+        end
+
+        def initialize
+          super
+          raise "ActiveRecord models not available. Run the generator to create them." unless self.class.available?
+        end
+
+        def save_test(test)
+          record = ::ABTestModel.create!(
+            name: test.name,
+            champion_version_id: test.champion_version_id,
+            challenger_version_id: test.challenger_version_id,
+            traffic_split: test.traffic_split,
+            start_date: test.start_date,
+            end_date: test.end_date,
+            status: test.status
+          )
+
+          to_ab_test(record)
+        end
+
+        def get_test(test_id)
+          record = ::ABTestModel.find_by(id: test_id)
+          record ? to_ab_test(record) : nil
+        end
+
+        def update_test(test_id, attributes)
+          record = ::ABTestModel.find(test_id)
+          record.update!(attributes)
+          to_ab_test(record)
+        end
+
+        def list_tests(status: nil, limit: nil)
+          query = ::ABTestModel.order(created_at: :desc)
+          query = query.where(status: status) if status
+          query = query.limit(limit) if limit
+
+          query.map { |record| to_ab_test(record) }
+        end
+
+        def save_assignment(assignment)
+          record = ::ABTestAssignmentModel.create!(
+            ab_test_id: assignment.ab_test_id,
+            user_id: assignment.user_id,
+            variant: assignment.variant.to_s,
+            version_id: assignment.version_id,
+            decision_result: assignment.decision_result,
+            confidence: assignment.confidence,
+            context: assignment.context,
+            timestamp: assignment.timestamp
+          )
+
+          to_assignment(record)
+        end
+
+        def update_assignment(assignment_id, attributes)
+          record = ::ABTestAssignmentModel.find(assignment_id)
+          record.update!(attributes)
+          to_assignment(record)
+        end
+
+        def get_assignments(test_id)
+          ::ABTestAssignmentModel
+            .where(ab_test_id: test_id)
+            .order(timestamp: :desc)
+            .map { |record| to_assignment(record) }
+        end
+
+        # rubocop:disable Naming/PredicateMethod
+        def delete_test(test_id)
+          record = ::ABTestModel.find(test_id)
+          ::ABTestAssignmentModel.where(ab_test_id: test_id).delete_all
+          record.destroy
+          true
+        end
+        # rubocop:enable Naming/PredicateMethod
+
+        # Get statistics from database
+        def get_test_statistics(test_id)
+          assignments = ::ABTestAssignmentModel.where(ab_test_id: test_id)
+
+          {
+            total_assignments: assignments.count,
+            champion_count: assignments.where(variant: "champion").count,
+            challenger_count: assignments.where(variant: "challenger").count,
+            with_decisions: assignments.where.not(decision_result: nil).count,
+            avg_confidence: assignments.where.not(confidence: nil).average(:confidence)&.to_f
+          }
+        end
+
+        private
+
+        def to_ab_test(record)
+          ABTest.new(
+            id: record.id,
+            name: record.name,
+            champion_version_id: record.champion_version_id,
+            challenger_version_id: record.challenger_version_id,
+            traffic_split: parse_traffic_split(record.traffic_split),
+            start_date: record.start_date,
+            end_date: record.end_date,
+            status: record.status
+          )
+        end
+
+        def to_assignment(record)
+          ABTestAssignment.new(
+            id: record.id,
+            ab_test_id: record.ab_test_id,
+            user_id: record.user_id,
+            variant: record.variant.to_sym,
+            version_id: record.version_id,
+            timestamp: record.timestamp,
+            decision_result: record.decision_result,
+            confidence: record.confidence,
+            context: parse_context(record.context)
+          )
+        end
+
+        def parse_traffic_split(value)
+          case value
+          when Hash
+            value.symbolize_keys
+          when String
+            JSON.parse(value).symbolize_keys
+          else
+            value
+          end
+        end
+
+        def parse_context(value)
+          case value
+          when Hash
+            value
+          when String
+            JSON.parse(value)
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/ab_testing/storage/adapter.rb

@@ -0,0 +1,67 @@
+module DecisionAgent
+  module ABTesting
+    module Storage
+      # Base adapter interface for A/B test persistence
+      class Adapter
+        # Save an A/B test
+        # @param test [ABTest] The test to save
+        # @return [ABTest] The saved test with ID
+        def save_test(test)
+          raise NotImplementedError, "#{self.class} must implement #save_test"
+        end
+
+        # Get an A/B test by ID
+        # @param test_id [String, Integer] The test ID
+        # @return [ABTest, nil] The test or nil
+        def get_test(test_id)
+          raise NotImplementedError, "#{self.class} must implement #get_test"
+        end
+
+        # Update an A/B test
+        # @param test_id [String, Integer] The test ID
+        # @param attributes [Hash] Attributes to update
+        # @return [ABTest] The updated test
+        def update_test(test_id, attributes)
+          raise NotImplementedError, "#{self.class} must implement #update_test"
+        end
+
+        # List A/B tests
+        # @param status [String, nil] Filter by status
+        # @param limit [Integer, nil] Limit results
+        # @return [Array<ABTest>] Array of tests
+        def list_tests(status: nil, limit: nil)
+          raise NotImplementedError, "#{self.class} must implement #list_tests"
+        end
+
+        # Save an assignment
+        # @param assignment [ABTestAssignment] The assignment to save
+        # @return [ABTestAssignment] The saved assignment with ID
+        def save_assignment(assignment)
+          raise NotImplementedError, "#{self.class} must implement #save_assignment"
+        end
+
+        # Update an assignment
+        # @param assignment_id [String, Integer] The assignment ID
+        # @param attributes [Hash] Attributes to update
+        # @return [ABTestAssignment] The updated assignment
+        def update_assignment(assignment_id, attributes)
+          raise NotImplementedError, "#{self.class} must implement #update_assignment"
+        end
+
+        # Get assignments for a test
+        # @param test_id [String, Integer] The test ID
+        # @return [Array<ABTestAssignment>] Array of assignments
+        def get_assignments(test_id)
+          raise NotImplementedError, "#{self.class} must implement #get_assignments"
+        end
+
+        # Delete a test and its assignments
+        # @param test_id [String, Integer] The test ID
+        # @return [Boolean] True if deleted
+        def delete_test(test_id)
+          raise NotImplementedError, "#{self.class} must implement #delete_test"
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/ab_testing/storage/memory_adapter.rb

@@ -0,0 +1,116 @@
+require "monitor"
+
+module DecisionAgent
+  module ABTesting
+    module Storage
+      # In-memory storage adapter for A/B tests
+      # Useful for testing and development
+      class MemoryAdapter < Adapter
+        include MonitorMixin
+
+        def initialize
+          super
+          @tests = {}
+          @assignments = {}
+          @test_id_counter = 0
+          @assignment_id_counter = 0
+        end
+
+        def save_test(test)
+          synchronize do
+            @test_id_counter += 1
+            test_data = test.to_h.merge(id: @test_id_counter)
+            @tests[@test_id_counter] = test_data
+
+            ABTest.new(**test_data)
+          end
+        end
+
+        def get_test(test_id)
+          synchronize do
+            test_data = @tests[test_id.to_i]
+            test_data ? ABTest.new(**test_data) : nil
+          end
+        end
+
+        def update_test(test_id, attributes)
+          synchronize do
+            test_data = @tests[test_id.to_i]
+            raise TestNotFoundError, "Test not found: #{test_id}" unless test_data
+
+            test_data.merge!(attributes)
+            @tests[test_id.to_i] = test_data
+
+            ABTest.new(**test_data)
+          end
+        end
+
+        def list_tests(status: nil, limit: nil)
+          synchronize do
+            tests = @tests.values
+
+            tests = tests.select { |t| t[:status] == status } if status
+            tests = tests.last(limit) if limit
+
+            tests.map { |t| ABTest.new(**t) }
+          end
+        end
+
+        def save_assignment(assignment)
+          synchronize do
+            @assignment_id_counter += 1
+            assignment_data = assignment.to_h.merge(id: @assignment_id_counter)
+            @assignments[@assignment_id_counter] = assignment_data
+
+            ABTestAssignment.new(**assignment_data)
+          end
+        end
+
+        def update_assignment(assignment_id, attributes)
+          synchronize do
+            assignment_data = @assignments[assignment_id.to_i]
+            raise "Assignment not found: #{assignment_id}" unless assignment_data
+
+            assignment_data.merge!(attributes)
+            @assignments[assignment_id.to_i] = assignment_data
+
+            ABTestAssignment.new(**assignment_data)
+          end
+        end
+
+        def get_assignments(test_id)
+          synchronize do
+            assignments = @assignments.values.select { |a| a[:ab_test_id] == test_id }
+            assignments.map { |a| ABTestAssignment.new(**a) }
+          end
+        end
+
+        def delete_test(test_id)
+          synchronize do
+            @tests.delete(test_id.to_i)
+            @assignments.delete_if { |_id, a| a[:ab_test_id] == test_id }
+            true
+          end
+        end
+
+        # Additional helper methods
+        def clear!
+          synchronize do
+            @tests.clear
+            @assignments.clear
+            @test_id_counter = 0
+            @assignment_id_counter = 0
+          end
+        end
+
+        def test_count
+          synchronize { @tests.size }
+        end
+
+        def assignment_count
+          synchronize { @assignments.size }
+        end
+      end
+    end
+  end
+end