decision_agent 0.1.1

data/spec/replay_spec.rb

@@ -0,0 +1,210 @@
+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 {
+        DecisionAgent::Replay.run(modified_payload, strict: true)
+      }.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 {
+        DecisionAgent::Replay.run(modified_payload, strict: true)
+      }.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 {
+        DecisionAgent::Replay.run(modified_payload, strict: false)
+      }.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 {
+        DecisionAgent::Replay.run(modified_payload, strict: false)
+      }.to output(/Decision changed/).to_stderr
+    end
+
+    it "validates required fields in audit payload" do
+      invalid_payload = { context: {} }
+
+      expect {
+        DecisionAgent::Replay.run(invalid_payload, strict: true)
+      }.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(["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/scoring_spec.rb

@@ -0,0 +1,225 @@
+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(["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

@@ -0,0 +1,28 @@
+require "simplecov"
+SimpleCov.start do
+  add_filter "/spec/"
+  add_filter "/examples/"
+end
+
+require "decision_agent"
+
+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
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: decision_agent
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Sam Aswin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A production-grade decision agent that provides deterministic rule evaluation,
+  conflict resolution, and full audit replay capabilities. Framework-agnostic and
+  AI-optional.
+email:
+- samaswin87@gmail.com
+executables:
+- decision_agent
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/decision_agent
+- lib/decision_agent.rb
+- lib/decision_agent/agent.rb
+- lib/decision_agent/audit/adapter.rb
+- lib/decision_agent/audit/logger_adapter.rb
+- lib/decision_agent/audit/null_adapter.rb
+- lib/decision_agent/context.rb
+- lib/decision_agent/decision.rb
+- lib/decision_agent/dsl/condition_evaluator.rb
+- lib/decision_agent/dsl/rule_parser.rb
+- lib/decision_agent/dsl/schema_validator.rb
+- lib/decision_agent/errors.rb
+- lib/decision_agent/evaluation.rb
+- lib/decision_agent/evaluators/base.rb
+- lib/decision_agent/evaluators/json_rule_evaluator.rb
+- lib/decision_agent/evaluators/static_evaluator.rb
+- lib/decision_agent/replay/replay.rb
+- lib/decision_agent/scoring/base.rb
+- lib/decision_agent/scoring/consensus.rb
+- lib/decision_agent/scoring/max_weight.rb
+- lib/decision_agent/scoring/threshold.rb
+- lib/decision_agent/scoring/weighted_average.rb
+- lib/decision_agent/version.rb
+- lib/decision_agent/web/public/app.js
+- lib/decision_agent/web/public/index.html
+- lib/decision_agent/web/public/styles.css
+- lib/decision_agent/web/server.rb
+- spec/agent_spec.rb
+- spec/api_contract_spec.rb
+- spec/audit_adapters_spec.rb
+- spec/comprehensive_edge_cases_spec.rb
+- spec/context_spec.rb
+- spec/dsl_validation_spec.rb
+- spec/edge_cases_spec.rb
+- spec/examples/feedback_aware_evaluator_spec.rb
+- spec/json_rule_evaluator_spec.rb
+- spec/replay_edge_cases_spec.rb
+- spec/replay_spec.rb
+- spec/scoring_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/samaswin87/decision_agent
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/samaswin87/decision_agent
+  source_code_uri: https://github.com/samaswin87/decision_agent
+  changelog_uri: https://github.com/samaswin87/decision_agent/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Deterministic, explainable, auditable decision engine for Ruby
+test_files: []