decision_agent 0.2.0 → 1.0.1

data/spec/replay_spec.rb

@@ -1,210 +0,0 @@
-require "spec_helper"
-
-RSpec.describe DecisionAgent::Replay do
-  let(:evaluator) do
-    DecisionAgent::Evaluators::StaticEvaluator.new(
-      decision: "approve",
-      weight: 0.8,
-      reason: "Static approval"
-    )
-  end
-
-  let(:agent) do
-    DecisionAgent::Agent.new(evaluators: [evaluator])
-  end
-
-  describe ".run" do
-    it "replays decision from audit payload in strict mode" do
-      context = { user: "alice", action: "login" }
-      original_result = agent.decide(context: context)
-
-      replayed_result = DecisionAgent::Replay.run(
-        original_result.audit_payload,
-        strict: true
-      )
-
-      expect(replayed_result.decision).to eq(original_result.decision)
-      expect(replayed_result.confidence).to be_within(0.0001).of(original_result.confidence)
-    end
-
-    it "raises ReplayMismatchError in strict mode when decision differs" do
-      context = { user: "alice" }
-      original_result = agent.decide(context: context)
-
-      modified_payload = original_result.audit_payload.dup
-      modified_payload[:decision] = "reject"
-
-      expect do
-        DecisionAgent::Replay.run(modified_payload, strict: true)
-      end.to raise_error(DecisionAgent::ReplayMismatchError) do |error|
-        expect(error.differences).to include(/decision mismatch/)
-        expect(error.expected[:decision]).to eq("reject")
-        expect(error.actual[:decision]).to eq("approve")
-      end
-    end
-
-    it "raises ReplayMismatchError in strict mode when confidence differs" do
-      context = { user: "alice" }
-      original_result = agent.decide(context: context)
-
-      modified_payload = original_result.audit_payload.dup
-      modified_payload[:confidence] = 0.5
-
-      expect do
-        DecisionAgent::Replay.run(modified_payload, strict: true)
-      end.to raise_error(DecisionAgent::ReplayMismatchError) do |error|
-        expect(error.differences).to include(/confidence mismatch/)
-      end
-    end
-
-    it "allows differences in non-strict mode" do
-      context = { user: "alice" }
-      original_result = agent.decide(context: context)
-
-      modified_payload = original_result.audit_payload.dup
-      modified_payload[:decision] = "reject"
-
-      expect do
-        DecisionAgent::Replay.run(modified_payload, strict: false)
-      end.not_to raise_error
-    end
-
-    it "logs differences in non-strict mode" do
-      context = { user: "alice" }
-      original_result = agent.decide(context: context)
-
-      modified_payload = original_result.audit_payload.dup
-      modified_payload[:decision] = "reject"
-
-      expect do
-        DecisionAgent::Replay.run(modified_payload, strict: false)
-      end.to output(/Decision changed/).to_stderr
-    end
-
-    it "validates required fields in audit payload" do
-      invalid_payload = { context: {} }
-
-      expect do
-        DecisionAgent::Replay.run(invalid_payload, strict: true)
-      end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key/)
-    end
-
-    it "reconstructs evaluations from audit payload" do
-      eval1 = DecisionAgent::Evaluators::StaticEvaluator.new(
-        decision: "approve",
-        weight: 0.7,
-        reason: "Eval 1",
-        name: "Evaluator1"
-      )
-      eval2 = DecisionAgent::Evaluators::StaticEvaluator.new(
-        decision: "approve",
-        weight: 0.9,
-        reason: "Eval 2",
-        name: "Evaluator2"
-      )
-
-      multi_agent = DecisionAgent::Agent.new(evaluators: [eval1, eval2])
-      original_result = multi_agent.decide(context: { user: "bob" })
-
-      replayed_result = DecisionAgent::Replay.run(
-        original_result.audit_payload,
-        strict: true
-      )
-
-      expect(replayed_result.evaluations.size).to eq(2)
-      expect(replayed_result.evaluations.map(&:evaluator_name)).to match_array(%w[Evaluator1 Evaluator2])
-    end
-
-    it "uses correct scoring strategy from audit payload" do
-      max_weight_agent = DecisionAgent::Agent.new(
-        evaluators: [evaluator],
-        scoring_strategy: DecisionAgent::Scoring::MaxWeight.new
-      )
-
-      original_result = max_weight_agent.decide(context: { user: "charlie" })
-
-      expect(original_result.audit_payload[:scoring_strategy]).to include("MaxWeight")
-
-      replayed_result = DecisionAgent::Replay.run(
-        original_result.audit_payload,
-        strict: true
-      )
-
-      expect(replayed_result.decision).to eq(original_result.decision)
-    end
-
-    it "handles symbol and string keys in audit payload" do
-      context = { user: "alice" }
-      original_result = agent.decide(context: context)
-
-      string_key_payload = JSON.parse(JSON.generate(original_result.audit_payload))
-
-      replayed_result = DecisionAgent::Replay.run(
-        string_key_payload,
-        strict: true
-      )
-
-      expect(replayed_result.decision).to eq(original_result.decision)
-    end
-
-    it "preserves feedback in replay" do
-      context = { user: "alice" }
-      feedback = { source: "manual_override" }
-
-      original_result = agent.decide(context: context, feedback: feedback)
-
-      replayed_result = DecisionAgent::Replay.run(
-        original_result.audit_payload,
-        strict: true
-      )
-
-      expect(replayed_result.audit_payload[:feedback]).to eq(feedback)
-    end
-  end
-
-  describe "deterministic replay" do
-    it "produces identical results for identical inputs across multiple replays" do
-      context = { user: "alice", priority: "high" }
-      original_result = agent.decide(context: context)
-
-      results = 5.times.map do
-        DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
-      end
-
-      results.each do |result|
-        expect(result.decision).to eq(original_result.decision)
-        expect(result.confidence).to be_within(0.0001).of(original_result.confidence)
-      end
-    end
-  end
-
-  describe "complex scenario replay" do
-    it "replays decisions from JSON rule evaluators" do
-      rules = {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "high_priority",
-            if: { field: "priority", op: "eq", value: "high" },
-            then: { decision: "escalate", weight: 0.9, reason: "High priority issue" }
-          }
-        ]
-      }
-
-      json_evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
-      json_agent = DecisionAgent::Agent.new(evaluators: [json_evaluator])
-
-      context = { priority: "high", user: "alice" }
-      original_result = json_agent.decide(context: context)
-
-      replayed_result = DecisionAgent::Replay.run(
-        original_result.audit_payload,
-        strict: true
-      )
-
-      expect(replayed_result.decision).to eq("escalate")
-      expect(replayed_result.confidence).to be_within(0.0001).of(original_result.confidence)
-    end
-  end
-end

data/spec/rfc8785_canonicalization_spec.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "RFC 8785 JSON Canonicalization" do
-  let(:evaluator) do
-    DecisionAgent::Evaluators::JsonRuleEvaluator.new(
-      rules_json: {
-        version: "1.0",
-        ruleset: "test",
-        rules: [
-          {
-            id: "always_approve",
-            if: { field: "amount", op: "gte", value: 0 },
-            then: { decision: "approve", weight: 1.0, reason: "Test rule" }
-          }
-        ]
-      }
-    )
-  end
-
-  let(:agent) { DecisionAgent::Agent.new(evaluators: [evaluator]) }
-
-  describe "canonical JSON serialization" do
-    it "produces deterministic hashes using RFC 8785" do
-      # Same context should produce same hash every time
-      context = { amount: 100, user: { id: 123, name: "Alice" } }
-
-      decision1 = agent.decide(context: context)
-      decision2 = agent.decide(context: context)
-
-      hash1 = decision1.audit_payload[:deterministic_hash]
-      hash2 = decision2.audit_payload[:deterministic_hash]
-
-      expect(hash1).to eq(hash2)
-      expect(hash1).to be_a(String)
-      expect(hash1.length).to eq(64) # SHA256 produces 64 hex characters
-    end
-
-    it "produces different hashes for different contexts" do
-      context1 = { amount: 100, user: { id: 123 } }
-      context2 = { amount: 200, user: { id: 456 } }
-
-      decision1 = agent.decide(context: context1)
-      decision2 = agent.decide(context: context2)
-
-      hash1 = decision1.audit_payload[:deterministic_hash]
-      hash2 = decision2.audit_payload[:deterministic_hash]
-
-      expect(hash1).not_to eq(hash2)
-    end
-
-    it "is insensitive to property order (canonicalization)" do
-      # Different property order should produce same hash
-      context1 = { amount: 100, user: { id: 123, name: "Alice" } }
-      context2 = { user: { name: "Alice", id: 123 }, amount: 100 }
-
-      decision1 = agent.decide(context: context1)
-      decision2 = agent.decide(context: context2)
-
-      hash1 = decision1.audit_payload[:deterministic_hash]
-      hash2 = decision2.audit_payload[:deterministic_hash]
-
-      expect(hash1).to eq(hash2), "RFC 8785 canonicalization should sort properties"
-    end
-
-    it "handles special characters correctly" do
-      # Test Unicode, quotes, and control characters
-      context = {
-        amount: 100,
-        note: "Test with \"quotes\", €uro, and \n newline"
-      }
-
-      decision = agent.decide(context: context)
-      hash = decision.audit_payload[:deterministic_hash]
-
-      expect(hash).to be_a(String)
-      expect(hash.length).to eq(64)
-    end
-
-    it "handles floating point numbers deterministically" do
-      # RFC 8785 specifies exact float serialization per IEEE 754
-      # Note: 99.99 cannot be exactly represented in binary floating point
-      context = { amount: 100, price: 99.99, tax: 0.075 }
-
-      decision1 = agent.decide(context: context)
-      decision2 = agent.decide(context: context)
-
-      hash1 = decision1.audit_payload[:deterministic_hash]
-      hash2 = decision2.audit_payload[:deterministic_hash]
-
-      # Same context should always produce same hash
-      expect(hash1).to eq(hash2), "RFC 8785 should produce consistent hashes for same values"
-
-      # Verify RFC 8785 uses ECMAScript number serialization
-      canonical = agent.send(:canonical_json, context)
-      # RFC 8785 may represent 99.99 as 99.98999999999999 due to IEEE 754
-      expect(canonical).to match(/99\.\d+/)
-      expect(canonical).to include("0.075")
-    end
-
-    it "handles nested structures correctly" do
-      context = {
-        amount: 100,
-        user: {
-          id: 123,
-          profile: {
-            name: "Alice",
-            tags: %w[premium verified]
-          }
-        }
-      }
-
-      decision = agent.decide(context: context)
-      hash = decision.audit_payload[:deterministic_hash]
-
-      expect(hash).to be_a(String)
-      expect(hash.length).to eq(64)
-    end
-
-    it "handles arrays consistently" do
-      # Array order should be preserved (not sorted)
-      context1 = { amount: 100, tags: %w[a b c] }
-      context2 = { amount: 100, tags: %w[c b a] }
-
-      decision1 = agent.decide(context: context1)
-      decision2 = agent.decide(context: context2)
-
-      hash1 = decision1.audit_payload[:deterministic_hash]
-      hash2 = decision2.audit_payload[:deterministic_hash]
-
-      expect(hash1).not_to eq(hash2), "RFC 8785 preserves array order"
-    end
-
-    it "handles nil values correctly" do
-      context = { amount: 100, optional_field: nil }
-
-      decision = agent.decide(context: context)
-      hash = decision.audit_payload[:deterministic_hash]
-
-      expect(hash).to be_a(String)
-      expect(hash.length).to eq(64)
-    end
-
-    it "handles boolean values correctly" do
-      context = { amount: 100, is_verified: true, is_blocked: false }
-
-      decision = agent.decide(context: context)
-      hash = decision.audit_payload[:deterministic_hash]
-
-      expect(hash).to be_a(String)
-      expect(hash.length).to eq(64)
-    end
-
-    it "is thread-safe with concurrent hash computations" do
-      contexts = 10.times.map { |i| { amount: i * 100, id: i } }
-      results = []
-      mutex = Mutex.new
-
-      threads = contexts.map do |ctx|
-        Thread.new do
-          decision = agent.decide(context: ctx)
-          hash = decision.audit_payload[:deterministic_hash]
-          mutex.synchronize { results << hash }
-        end
-      end
-
-      threads.each(&:join)
-
-      expect(results.size).to eq(10)
-      expect(results.uniq.size).to eq(10), "Each context should produce unique hash"
-      results.each do |hash|
-        expect(hash.length).to eq(64)
-      end
-    end
-  end
-
-  describe "RFC 8785 compliance" do
-    it "uses json-canonicalization gem for canonicalization" do
-      # Verify we're using the RFC 8785 implementation
-      test_data = { b: 2, a: 1 }
-      canonical = agent.send(:canonical_json, test_data)
-
-      # RFC 8785 should sort keys: {"a":1,"b":2}
-      expect(canonical).to include('"a":1')
-      expect(canonical).to include('"b":2')
-      expect(canonical.index('"a"')).to be < canonical.index('"b"')
-    end
-
-    it "produces compact JSON without whitespace" do
-      test_data = { amount: 100, user: { id: 123 } }
-      canonical = agent.send(:canonical_json, test_data)
-
-      # RFC 8785 produces compact JSON
-      expect(canonical).not_to include("\n")
-      expect(canonical).not_to include("  ")
-    end
-  end
-
-  describe "performance characteristics" do
-    it "computes hashes efficiently" do
-      context = {
-        amount: 100,
-        user: { id: 123, name: "Alice", tags: (1..100).to_a }
-      }
-
-      # Should complete quickly even with larger payloads
-      start_time = Time.now
-      100.times { agent.decide(context: context) }
-      elapsed = Time.now - start_time
-
-      expect(elapsed).to be < 1.0, "100 decisions should complete in under 1 second"
-    end
-  end
-end

data/spec/scoring_spec.rb

@@ -1,225 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "Scoring Strategies" do
-  let(:eval1) do
-    DecisionAgent::Evaluation.new(
-      decision: "approve",
-      weight: 0.6,
-      reason: "Test 1",
-      evaluator_name: "Eval1"
-    )
-  end
-
-  let(:eval2) do
-    DecisionAgent::Evaluation.new(
-      decision: "approve",
-      weight: 0.8,
-      reason: "Test 2",
-      evaluator_name: "Eval2"
-    )
-  end
-
-  let(:eval3) do
-    DecisionAgent::Evaluation.new(
-      decision: "reject",
-      weight: 0.5,
-      reason: "Test 3",
-      evaluator_name: "Eval3"
-    )
-  end
-
-  describe DecisionAgent::Scoring::WeightedAverage do
-    it "calculates weighted average for single decision" do
-      strategy = DecisionAgent::Scoring::WeightedAverage.new
-      result = strategy.score([eval1, eval2])
-
-      expect(result[:decision]).to eq("approve")
-      expect(result[:confidence]).to eq(1.0)
-    end
-
-    it "calculates weighted average with conflicts" do
-      strategy = DecisionAgent::Scoring::WeightedAverage.new
-      result = strategy.score([eval1, eval2, eval3])
-
-      total_weight = 0.6 + 0.8 + 0.5
-      approve_weight = 0.6 + 0.8
-      expected_confidence = approve_weight / total_weight
-
-      expect(result[:decision]).to eq("approve")
-      expect(result[:confidence]).to be_within(0.0001).of(expected_confidence)
-    end
-
-    it "returns 0 confidence for empty evaluations" do
-      strategy = DecisionAgent::Scoring::WeightedAverage.new
-      result = strategy.score([])
-
-      expect(result[:decision]).to be_nil
-      expect(result[:confidence]).to eq(0.0)
-    end
-
-    it "normalizes confidence to [0, 1]" do
-      strategy = DecisionAgent::Scoring::WeightedAverage.new
-      result = strategy.score([eval1])
-
-      expect(result[:confidence]).to be_between(0.0, 1.0)
-    end
-  end
-
-  describe DecisionAgent::Scoring::MaxWeight do
-    it "selects decision with maximum weight" do
-      strategy = DecisionAgent::Scoring::MaxWeight.new
-      result = strategy.score([eval1, eval2, eval3])
-
-      expect(result[:decision]).to eq("approve")
-      expect(result[:confidence]).to eq(0.8)
-    end
-
-    it "uses first evaluation when weights are equal" do
-      eval_a = DecisionAgent::Evaluation.new(
-        decision: "option_a",
-        weight: 0.7,
-        reason: "Test A",
-        evaluator_name: "EvalA"
-      )
-      eval_b = DecisionAgent::Evaluation.new(
-        decision: "option_b",
-        weight: 0.7,
-        reason: "Test B",
-        evaluator_name: "EvalB"
-      )
-
-      strategy = DecisionAgent::Scoring::MaxWeight.new
-      result = strategy.score([eval_a, eval_b])
-
-      expect(%w[option_a option_b]).to include(result[:decision])
-      expect(result[:confidence]).to eq(0.7)
-    end
-
-    it "returns 0 confidence for empty evaluations" do
-      strategy = DecisionAgent::Scoring::MaxWeight.new
-      result = strategy.score([])
-
-      expect(result[:decision]).to be_nil
-      expect(result[:confidence]).to eq(0.0)
-    end
-  end
-
-  describe DecisionAgent::Scoring::Consensus do
-    it "selects decision with highest agreement" do
-      eval4 = DecisionAgent::Evaluation.new(
-        decision: "approve",
-        weight: 0.7,
-        reason: "Test 4",
-        evaluator_name: "Eval4"
-      )
-
-      strategy = DecisionAgent::Scoring::Consensus.new
-      result = strategy.score([eval1, eval2, eval3, eval4])
-
-      expect(result[:decision]).to eq("approve")
-    end
-
-    it "considers both agreement and weight" do
-      low_weight_majority = [
-        DecisionAgent::Evaluation.new(decision: "approve", weight: 0.3, reason: "A", evaluator_name: "E1"),
-        DecisionAgent::Evaluation.new(decision: "approve", weight: 0.3, reason: "B", evaluator_name: "E2"),
-        DecisionAgent::Evaluation.new(decision: "approve", weight: 0.3, reason: "C", evaluator_name: "E3")
-      ]
-
-      high_weight_minority = [
-        DecisionAgent::Evaluation.new(decision: "reject", weight: 0.9, reason: "D", evaluator_name: "E4")
-      ]
-
-      strategy = DecisionAgent::Scoring::Consensus.new
-      result = strategy.score(low_weight_majority + high_weight_minority)
-
-      expect(result[:decision]).to eq("approve")
-    end
-
-    it "reduces confidence when minimum agreement not met" do
-      eval_spread = [
-        DecisionAgent::Evaluation.new(decision: "option_a", weight: 0.8, reason: "A", evaluator_name: "E1"),
-        DecisionAgent::Evaluation.new(decision: "option_b", weight: 0.7, reason: "B", evaluator_name: "E2"),
-        DecisionAgent::Evaluation.new(decision: "option_c", weight: 0.6, reason: "C", evaluator_name: "E3")
-      ]
-
-      strategy = DecisionAgent::Scoring::Consensus.new(minimum_agreement: 0.5)
-      result = strategy.score(eval_spread)
-
-      expect(result[:confidence]).to be < 0.5
-    end
-
-    it "allows custom minimum agreement threshold" do
-      strategy = DecisionAgent::Scoring::Consensus.new(minimum_agreement: 0.7)
-      result = strategy.score([eval1, eval2, eval3])
-
-      expect(result[:decision]).to eq("approve")
-    end
-
-    it "returns 0 confidence for empty evaluations" do
-      strategy = DecisionAgent::Scoring::Consensus.new
-      result = strategy.score([])
-
-      expect(result[:decision]).to be_nil
-      expect(result[:confidence]).to eq(0.0)
-    end
-  end
-
-  describe DecisionAgent::Scoring::Threshold do
-    it "accepts decision when weight meets threshold" do
-      strategy = DecisionAgent::Scoring::Threshold.new(threshold: 0.7)
-      result = strategy.score([eval2])
-
-      expect(result[:decision]).to eq("approve")
-      expect(result[:confidence]).to eq(0.8)
-    end
-
-    it "returns fallback decision when weight below threshold" do
-      strategy = DecisionAgent::Scoring::Threshold.new(threshold: 0.9, fallback_decision: "manual_review")
-      result = strategy.score([eval2])
-
-      expect(result[:decision]).to eq("manual_review")
-      expect(result[:confidence]).to be < 0.9
-    end
-
-    it "uses average weight across evaluations with same decision" do
-      strategy = DecisionAgent::Scoring::Threshold.new(threshold: 0.7)
-      result = strategy.score([eval1, eval2])
-
-      avg_weight = (0.6 + 0.8) / 2
-      expect(result[:decision]).to eq("approve")
-      expect(result[:confidence]).to eq(avg_weight)
-    end
-
-    it "uses default fallback decision" do
-      strategy = DecisionAgent::Scoring::Threshold.new(threshold: 0.9)
-      result = strategy.score([eval1])
-
-      expect(result[:decision]).to eq("no_decision")
-    end
-
-    it "returns fallback for empty evaluations" do
-      strategy = DecisionAgent::Scoring::Threshold.new(fallback_decision: "default")
-      result = strategy.score([])
-
-      expect(result[:decision]).to eq("default")
-      expect(result[:confidence]).to eq(0.0)
-    end
-  end
-
-  describe "confidence bounds" do
-    it "ensures all strategies return confidence between 0 and 1" do
-      strategies = [
-        DecisionAgent::Scoring::WeightedAverage.new,
-        DecisionAgent::Scoring::MaxWeight.new,
-        DecisionAgent::Scoring::Consensus.new,
-        DecisionAgent::Scoring::Threshold.new
-      ]
-
-      strategies.each do |strategy|
-        result = strategy.score([eval1, eval2, eval3])
-        expect(result[:confidence]).to be_between(0.0, 1.0)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,60 +0,0 @@
-require "simplecov"
-SimpleCov.start do
-  add_filter "/spec/"
-  add_filter "/examples/"
-end
-
-require "decision_agent"
-
-# Load ActiveRecord for thread-safety and integration tests
-begin
-  require "active_record"
-  require "sqlite3"
-  require "decision_agent/versioning/activerecord_adapter"
-rescue LoadError
-  # ActiveRecord is optional - tests will be skipped if not available
-end
-
-# Store original value for cleanup
-# rubocop:disable Style/GlobalVars
-$original_disable_webui_permissions = nil
-# rubocop:enable Style/GlobalVars
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-  config.filter_run_when_matching :focus
-  config.example_status_persistence_file_path = "spec/examples.txt"
-  config.disable_monkey_patching!
-  config.warnings = true
-
-  config.default_formatter = "doc" if config.files_to_run.one?
-
-  config.order = :random
-  Kernel.srand config.seed
-
-  # Ensure permissions are enabled for tests
-  config.before(:suite) do
-    # rubocop:disable Style/GlobalVars
-    $original_disable_webui_permissions = ENV.fetch("DISABLE_WEBUI_PERMISSIONS", nil)
-    # rubocop:enable Style/GlobalVars
-    ENV["DISABLE_WEBUI_PERMISSIONS"] = "false"
-  end
-
-  config.after(:suite) do
-    # rubocop:disable Style/GlobalVars
-    if $original_disable_webui_permissions
-      ENV["DISABLE_WEBUI_PERMISSIONS"] = $original_disable_webui_permissions
-    else
-      ENV.delete("DISABLE_WEBUI_PERMISSIONS")
-    end
-    # rubocop:enable Style/GlobalVars
-  end
-end