decision_agent 0.1.7 → 0.2.0

data/spec/advanced_operators_spec.rb

@@ -385,6 +385,1244 @@ RSpec.describe "Advanced DSL Operators" do
         expect(evaluation).to be_nil
       end
     end
+
+    # MATHEMATICAL FUNCTIONS
+    describe "trigonometric functions" do
+      describe "sin operator" do
+        it "matches when sin(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "sin", value: 0.0 },
+                then: { decision: "zero_angle" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: 0 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("zero_angle")
+        end
+
+        it "matches when sin(pi/2) equals 1" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "sin", value: 1.0 },
+                then: { decision: "right_angle" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: Math::PI / 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("right_angle")
+        end
+
+        it "does not match when sin value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "sin", value: 1.0 },
+                then: { decision: "right_angle" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: Math::PI })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "cos operator" do
+        it "matches when cos(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "cos", value: 1.0 },
+                then: { decision: "zero_angle" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: 0 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("zero_angle")
+        end
+
+        it "does not match when cos value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "cos", value: 1.0 },
+                then: { decision: "zero_angle" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: Math::PI / 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "tan operator" do
+        it "matches when tan(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "tan", value: 0.0 },
+                then: { decision: "zero_tangent" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: 0 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("zero_tangent")
+        end
+
+        it "does not match when tan value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "tan", value: 0.0 },
+                then: { decision: "zero_tangent" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: Math::PI / 4 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+    end
+
+    describe "exponential and logarithmic functions" do
+      describe "sqrt operator" do
+        it "matches when sqrt(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "number", op: "sqrt", value: 3.0 },
+                then: { decision: "square_root" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ number: 9 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("square_root")
+        end
+
+        it "does not match when sqrt value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "number", op: "sqrt", value: 3.0 },
+                then: { decision: "square_root" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ number: 16 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "does not match for negative numbers" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "number", op: "sqrt", value: 0.0 },
+                then: { decision: "square_root" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ number: -4 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "power operator" do
+        it "matches when power(field_value, exponent) equals result (array format)" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: [2, 4] },
+                then: { decision: "power_match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("power_match")
+        end
+
+        it "matches when power(field_value, exponent) equals result (hash format)" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: { exponent: 3, result: 8 } },
+                then: { decision: "power_match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("power_match")
+        end
+
+        it "does not match when power result is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: [2, 4] },
+                then: { decision: "power_match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 3 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "exp operator" do
+        it "matches when exp(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "exponent", op: "exp", value: Math::E },
+                then: { decision: "e_power" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ exponent: 1 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("e_power")
+        end
+
+        it "does not match when exp value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "exponent", op: "exp", value: Math::E },
+                then: { decision: "e_power" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ exponent: 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "log operator" do
+        it "matches when log(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "number", op: "log", value: 0.0 },
+                then: { decision: "log_one" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ number: 1 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("log_one")
+        end
+
+        it "does not match when log value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "number", op: "log", value: 0.0 },
+                then: { decision: "log_one" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ number: 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "does not match for non-positive numbers" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "number", op: "log", value: 0.0 },
+                then: { decision: "log_one" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ number: -1 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+    end
+
+    describe "rounding and absolute value functions" do
+      describe "round operator" do
+        it "matches when round(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "round", value: 3 },
+                then: { decision: "rounded" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 3.4 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("rounded")
+        end
+
+        it "matches when rounding up" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "round", value: 4 },
+                then: { decision: "rounded" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 3.6 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("rounded")
+        end
+
+        it "does not match when rounded value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "round", value: 3 },
+                then: { decision: "rounded" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 2.3 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "floor operator" do
+        it "matches when floor(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "floor", value: 3 },
+                then: { decision: "floored" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 3.9 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("floored")
+        end
+
+        it "does not match when floor value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "floor", value: 3 },
+                then: { decision: "floored" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 2.5 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "ceil operator" do
+        it "matches when ceil(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "ceil", value: 4 },
+                then: { decision: "ceiled" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 3.1 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("ceiled")
+        end
+
+        it "does not match when ceil value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "ceil", value: 4 },
+                then: { decision: "ceiled" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 2.1 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "abs operator" do
+        it "matches when abs(field_value) equals expected_value for positive" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "abs", value: 5 },
+                then: { decision: "absolute" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: 5 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("absolute")
+        end
+
+        it "matches when abs(field_value) equals expected_value for negative" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "abs", value: 5 },
+                then: { decision: "absolute" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: -5 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("absolute")
+        end
+
+        it "does not match when abs value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "abs", value: 5 },
+                then: { decision: "absolute" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: -3 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+    end
+
+    describe "aggregation functions" do
+      describe "min operator" do
+        it "matches when min(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "min", value: 1 },
+                then: { decision: "min_found" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [3, 1, 5, 2] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("min_found")
+        end
+
+        it "does not match when min value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "min", value: 1 },
+                then: { decision: "min_found" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [3, 5, 2] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "does not match for empty arrays" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "min", value: 1 },
+                then: { decision: "min_found" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "max operator" do
+        it "matches when max(field_value) equals expected_value" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "max", value: 5 },
+                then: { decision: "max_found" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [3, 1, 5, 2] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("max_found")
+        end
+
+        it "does not match when max value is different" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "max", value: 5 },
+                then: { decision: "max_found" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [3, 1, 2] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "does not match for empty arrays" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "max", value: 5 },
+                then: { decision: "max_found" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+    end
+
+    # EDGE CASES FOR MATHEMATICAL OPERATORS
+    describe "edge cases for mathematical operators" do
+      describe "non-numeric values" do
+        it "handles string values gracefully for sin" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "sin", value: 0.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: "not_a_number" })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "handles string values gracefully for sqrt" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "sqrt", value: 3.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: "invalid" })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "handles string values gracefully for round" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "round", value: 3 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: "not_numeric" })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "handles non-array values gracefully for min" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "min", value: 1 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: "not_an_array" })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "missing or nil values" do
+        it "handles missing field gracefully for sin" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "missing", op: "sin", value: 0.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({})
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "handles nil value gracefully for sqrt" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "sqrt", value: 3.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: nil })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+
+        it "handles nil value gracefully for min" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "value", op: "min", value: 1 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ value: nil })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "floating point precision" do
+        it "handles floating point precision for sin" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "sin", value: 0.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          # sin(0) should be exactly 0.0
+          context = DecisionAgent::Context.new({ angle: 0.0 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+
+        it "handles floating point precision for cos" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "angle", op: "cos", value: 1.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ angle: 0.0 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+      end
+
+      describe "very large numbers" do
+        it "handles very large numbers for exp" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "exponent", op: "exp", value: Math.exp(10) },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ exponent: 10 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+
+        it "handles very large numbers for power" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: [3, 27] },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 3 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+      end
+
+      describe "integration with all/any conditions" do
+        it "works with all condition combining multiple mathematical operators" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: {
+                  all: [
+                    { field: "angle", op: "sin", value: 0.0 },
+                    { field: "number", op: "sqrt", value: 3.0 },
+                    { field: "value", op: "abs", value: 5 }
+                  ]
+                },
+                then: { decision: "all_match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({
+                                                 angle: 0,
+                                                 number: 9,
+                                                 value: -5
+                                               })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("all_match")
+        end
+
+        it "works with any condition combining multiple mathematical operators" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: {
+                  any: [
+                    { field: "angle", op: "sin", value: 1.0 },
+                    { field: "number", op: "sqrt", value: 4.0 },
+                    { field: "value", op: "abs", value: 10 }
+                  ]
+                },
+                then: { decision: "any_match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({
+                                                 angle: 0, # sin(0) = 0, not 1
+                                                 number: 9,  # sqrt(9) = 3, not 4
+                                                 value: -10  # abs(-10) = 10, matches!
+                                               })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("any_match")
+        end
+      end
+
+      describe "nested field access" do
+        it "works with nested fields for sin" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "math.angle", op: "sin", value: 0.0 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ math: { angle: 0 } })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+
+        it "works with nested fields for min" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "data.numbers", op: "min", value: 1 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ data: { numbers: [3, 1, 5, 2] } })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+      end
+
+      describe "power operator edge cases" do
+        it "handles power with zero exponent" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: [0, 1] },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 5 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+
+        it "handles power with negative exponent" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: [-1, 0.5] },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+
+        it "handles invalid power parameters gracefully" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "base", op: "power", value: "invalid" },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ base: 2 })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).to be_nil
+        end
+      end
+
+      describe "min/max with mixed types" do
+        it "handles min with mixed numeric types" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "min", value: 1 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [3.5, 1, 5.0, 2] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+
+        it "handles max with mixed numeric types" do
+          rules = {
+            version: "1.0",
+            ruleset: "test",
+            rules: [
+              {
+                id: "rule_1",
+                if: { field: "numbers", op: "max", value: 5 },
+                then: { decision: "match" }
+              }
+            ]
+          }
+
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+          context = DecisionAgent::Context.new({ numbers: [1, 3.5, 5, 2.0] })
+
+          evaluation = evaluator.evaluate(context)
+
+          expect(evaluation).not_to be_nil
+          expect(evaluation.decision).to eq("match")
+        end
+      end
+    end
   end
 
   # DATE/TIME OPERATORS
@@ -1000,4 +2238,913 @@ RSpec.describe "Advanced DSL Operators" do
       expect(evaluation.decision).to eq("escalate")
     end
   end
+
+  # STATISTICAL AGGREGATIONS
+  describe "statistical aggregation operators" do
+    describe "sum operator" do
+      it "matches when sum equals expected value" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "amounts", op: "sum", value: 100 },
+              then: { decision: "total_match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ amounts: [30, 40, 30] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("total_match")
+      end
+
+      it "matches with comparison operators" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "prices", op: "sum", value: { gte: 100 } },
+              then: { decision: "free_shipping" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ prices: [25, 30, 50] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("free_shipping")
+      end
+
+      it "returns false for empty array" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "amounts", op: "sum", value: 0 },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ amounts: [] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).to be_nil
+      end
+
+      it "filters out non-numeric values" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "values", op: "sum", value: 15 },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ values: [5, "invalid", 10, nil] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+    end
+
+    describe "average operator" do
+      it "matches when average equals expected value" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "scores", op: "average", value: 50 },
+              then: { decision: "average_score" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ scores: [40, 50, 60] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("average_score")
+      end
+
+      it "matches with comparison operators" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "latencies", op: "average", value: { lt: 200 } },
+              then: { decision: "acceptable" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ latencies: [150, 180, 190] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("acceptable")
+      end
+    end
+
+    describe "mean operator" do
+      it "works as alias for average" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "values", op: "mean", value: 25 },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ values: [20, 25, 30] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+    end
+
+    describe "median operator" do
+      it "matches when median equals expected value" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "scores", op: "median", value: 50 },
+              then: { decision: "median_match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ scores: [40, 50, 60] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("median_match")
+      end
+
+      it "handles even number of elements" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "values", op: "median", value: 25 },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ values: [20, 30] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+    end
+
+    describe "stddev operator" do
+      it "matches when standard deviation meets threshold" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "values", op: "stddev", value: { lt: 5 } },
+              then: { decision: "low_variance" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ values: [10, 11, 12, 13, 14] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("low_variance")
+      end
+
+      it "returns false for arrays with less than 2 elements" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "values", op: "stddev", value: 0 },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ values: [10] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).to be_nil
+      end
+    end
+
+    describe "variance operator" do
+      it "matches when variance meets threshold" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "scores", op: "variance", value: { lt: 100 } },
+              then: { decision: "low_variance" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ scores: [50, 52, 48, 51, 49] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("low_variance")
+      end
+    end
+
+    describe "percentile operator" do
+      it "matches when percentile meets threshold" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "latencies", op: "percentile", value: { percentile: 95, threshold: 200 } },
+              then: { decision: "p95_ok" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ latencies: [100, 120, 150, 180, 190, 200, 210] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("p95_ok")
+      end
+
+      it "works with comparison operators" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "times", op: "percentile", value: { percentile: 99, gt: 500 } },
+              then: { decision: "high_p99" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ times: [100, 200, 300, 400, 500, 600, 700] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("high_p99")
+      end
+    end
+
+    describe "count operator" do
+      it "matches when count equals expected value" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "items", op: "count", value: 3 },
+              then: { decision: "three_items" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ items: %w[a b c] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("three_items")
+      end
+
+      it "matches with comparison operators" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "errors", op: "count", value: { gte: 5 } },
+              then: { decision: "alert" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ errors: %w[err1 err2 err3 err4 err5] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("alert")
+      end
+    end
+  end
+
+  # DURATION CALCULATIONS
+  describe "duration calculation operators" do
+    describe "duration_seconds operator" do
+      it "matches when duration is within threshold" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "start_time", op: "duration_seconds", value: { end: "now", max: 3600 } },
+              then: { decision: "within_hour" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ start_time: (Time.now - 1800).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("within_hour")
+      end
+
+      it "works with field path for end time" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "session.start", op: "duration_seconds", value: { end: "session.end", max: 7200 } },
+              then: { decision: "short_session" }
+            }
+          ]
+        }
+
+        start_time = Time.now - 3600
+        end_time = Time.now - 300
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({
+                                               session: {
+                                                 start: start_time.iso8601,
+                                                 end: end_time.iso8601
+                                               }
+                                             })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("short_session")
+      end
+    end
+
+    describe "duration_minutes operator" do
+      it "calculates duration in minutes" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "created_at", op: "duration_minutes", value: { end: "now", gte: 30 } },
+              then: { decision: "old_enough" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ created_at: (Time.now - 3600).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("old_enough")
+      end
+    end
+
+    describe "duration_hours and duration_days operators" do
+      it "calculates duration in hours" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "start", op: "duration_hours", value: { end: "now", gte: 1 } },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ start: (Time.now - 7200).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+
+      it "calculates duration in days" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "trial_start", op: "duration_days", value: { end: "now", gte: 7 } },
+              then: { decision: "trial_expired" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ trial_start: (Time.now - (8 * 86_400)).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("trial_expired")
+      end
+    end
+  end
+
+  # DATE ARITHMETIC
+  describe "date arithmetic operators" do
+    describe "add_days operator" do
+      it "adds days and compares with target" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "created_at", op: "add_days", value: { days: 7, compare: "lte", target: "now" } },
+              then: { decision: "week_old" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ created_at: (Time.now - (8 * 86_400)).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("week_old")
+      end
+    end
+
+    describe "subtract_days, add_hours, subtract_hours, add_minutes, subtract_minutes operators" do
+      it "subtracts days correctly" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "deadline", op: "subtract_days", value: { days: 1, compare: "gt", target: "now" } },
+              then: { decision: "not_urgent" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ deadline: (Time.now + (2 * 86_400)).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("not_urgent")
+      end
+
+      it "adds hours correctly" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "start", op: "add_hours", value: { hours: 2, compare: "lt", target: "now" } },
+              then: { decision: "past_2h" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ start: (Time.now - 7200).iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("past_2h")
+      end
+    end
+  end
+
+  # TIME COMPONENT EXTRACTION
+  describe "time component extraction operators" do
+    describe "hour_of_day operator" do
+      it "extracts hour and compares" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "timestamp", op: "hour_of_day", value: { gte: 9, lte: 17 } },
+              then: { decision: "business_hours" }
+            }
+          ]
+        }
+
+        time = Time.new(2025, 1, 1, 14, 0, 0)
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ timestamp: time.iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("business_hours")
+      end
+    end
+
+    describe "day_of_month, month, year, week_of_year operators" do
+      it "extracts day of month" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "date", op: "day_of_month", value: 15 },
+              then: { decision: "mid_month" }
+            }
+          ]
+        }
+
+        time = Time.new(2025, 1, 15, 12, 0, 0)
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ date: time.iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("mid_month")
+      end
+
+      it "extracts month" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "event_date", op: "month", value: 12 },
+              then: { decision: "december" }
+            }
+          ]
+        }
+
+        time = Time.new(2025, 12, 25, 12, 0, 0)
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ event_date: time.iso8601 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("december")
+      end
+    end
+  end
+
+  # RATE CALCULATIONS
+  describe "rate calculation operators" do
+    describe "rate_per_second operator" do
+      it "calculates rate per second from timestamps" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "request_timestamps", op: "rate_per_second", value: { max: 10 } },
+              then: { decision: "within_limit" }
+            }
+          ]
+        }
+
+        now = Time.now
+        timestamps = [
+          (now - 5).iso8601,
+          (now - 4).iso8601,
+          (now - 3).iso8601,
+          (now - 2).iso8601,
+          (now - 1).iso8601
+        ]
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ request_timestamps: timestamps })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("within_limit")
+      end
+    end
+
+    describe "rate_per_minute and rate_per_hour operators" do
+      it "calculates rate per minute" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "events", op: "rate_per_minute", value: { max: 60 } },
+              then: { decision: "ok" }
+            }
+          ]
+        }
+
+        now = Time.now
+        timestamps = [
+          (now - 60).iso8601,
+          (now - 30).iso8601,
+          now.iso8601
+        ]
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ events: timestamps })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("ok")
+      end
+    end
+  end
+
+  # MOVING WINDOW CALCULATIONS
+  describe "moving window operators" do
+    describe "moving_average operator" do
+      it "calculates moving average over window" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "metrics", op: "moving_average", value: { window: 5, lte: 100 } },
+              then: { decision: "low_avg" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ metrics: [80, 85, 90, 95, 100] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("low_avg")
+      end
+    end
+
+    describe "moving_sum, moving_max, moving_min operators" do
+      it "calculates moving sum" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "values", op: "moving_sum", value: { window: 3, gte: 25 } },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ values: [10, 10, 10, 5] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+    end
+  end
+
+  # FINANCIAL CALCULATIONS
+  describe "financial calculation operators" do
+    describe "compound_interest operator" do
+      it "calculates compound interest correctly" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "principal", op: "compound_interest", value: { rate: 0.05, periods: 12, result: 1051.16 } },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ principal: 1000 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+    end
+
+    describe "present_value and future_value operators" do
+      it "calculates present value" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "future_value", op: "present_value", value: { rate: 0.05, periods: 10, result: 613.91 } },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ future_value: 1000 })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+    end
+  end
+
+  # STRING AGGREGATIONS
+  describe "string aggregation operators" do
+    describe "join operator" do
+      it "joins array with separator and matches result" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "tags", op: "join", value: { separator: ",", result: "a,b,c" } },
+              then: { decision: "match" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ tags: %w[a b c] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("match")
+      end
+
+      it "matches with contains check" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "tags", op: "join", value: { separator: ",", contains: "important" } },
+              then: { decision: "has_important" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ tags: %w[urgent important critical] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("has_important")
+      end
+    end
+
+    describe "length operator" do
+      it "matches when string length meets threshold" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "description", op: "length", value: { min: 10, max: 500 } },
+              then: { decision: "valid_length" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ description: "This is a valid description" })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("valid_length")
+      end
+
+      it "works with arrays" do
+        rules = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [
+            {
+              id: "rule_1",
+              if: { field: "items", op: "length", value: { gte: 3 } },
+              then: { decision: "enough_items" }
+            }
+          ]
+        }
+
+        evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules)
+        context = DecisionAgent::Context.new({ items: %w[a b c d] })
+
+        evaluation = evaluator.evaluate(context)
+
+        expect(evaluation).not_to be_nil
+        expect(evaluation.decision).to eq("enough_items")
+      end
+    end
+  end
 end