decision_agent 0.1.1

data/lib/decision_agent/web/server.rb

@@ -0,0 +1,255 @@
+require "sinatra/base"
+require "json"
+
+module DecisionAgent
+  module Web
+    class Server < Sinatra::Base
+      set :public_folder, File.expand_path("public", __dir__)
+      set :views, File.expand_path("views", __dir__)
+      set :bind, "0.0.0.0"
+      set :port, 4567
+
+      # Enable CORS for API calls
+      before do
+        headers["Access-Control-Allow-Origin"] = "*"
+        headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+        headers["Access-Control-Allow-Headers"] = "Content-Type"
+      end
+
+      # OPTIONS handler for CORS preflight
+      options "*" do
+        200
+      end
+
+      # Main page - serve the rule builder UI
+      get "/" do
+        send_file File.join(settings.public_folder, "index.html")
+      end
+
+      # API: Validate rules
+      post "/api/validate" do
+        content_type :json
+
+        begin
+          # Parse request body
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          # Validate using DecisionAgent's SchemaValidator
+          DecisionAgent::Dsl::SchemaValidator.validate!(data)
+
+          # If validation passes
+          {
+            valid: true,
+            message: "Rules are valid!"
+          }.to_json
+
+        rescue JSON::ParserError => e
+          status 400
+          {
+            valid: false,
+            errors: ["Invalid JSON: #{e.message}"]
+          }.to_json
+
+        rescue DecisionAgent::InvalidRuleDslError => e
+          # Validation failed
+          status 422
+          {
+            valid: false,
+            errors: parse_validation_errors(e.message)
+          }.to_json
+
+        rescue => e
+          # Unexpected error
+          status 500
+          {
+            valid: false,
+            errors: ["Server error: #{e.message}"]
+          }.to_json
+        end
+      end
+
+      # API: Test rule evaluation (optional feature)
+      post "/api/evaluate" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          rules_json = data["rules"]
+          context = data["context"] || {}
+
+          # Create evaluator
+          evaluator = DecisionAgent::Evaluators::JsonRuleEvaluator.new(rules_json: rules_json)
+
+          # Evaluate
+          result = evaluator.evaluate(DecisionAgent::Context.new(context))
+
+          if result
+            {
+              success: true,
+              decision: result.decision,
+              weight: result.weight,
+              reason: result.reason,
+              evaluator_name: result.evaluator_name,
+              metadata: result.metadata
+            }.to_json
+          else
+            {
+              success: true,
+              decision: nil,
+              message: "No rules matched the given context"
+            }.to_json
+          end
+
+        rescue => e
+          status 500
+          {
+            success: false,
+            error: e.message
+          }.to_json
+        end
+      end
+
+      # API: Get example rules
+      get "/api/examples" do
+        content_type :json
+
+        examples = [
+          {
+            name: "Approval Workflow",
+            description: "Basic approval rules for requests",
+            rules: {
+              version: "1.0",
+              ruleset: "approval_workflow",
+              rules: [
+                {
+                  id: "admin_auto_approve",
+                  if: { field: "user.role", op: "eq", value: "admin" },
+                  then: { decision: "approve", weight: 0.95, reason: "Admin user" }
+                },
+                {
+                  id: "low_amount_approve",
+                  if: { field: "amount", op: "lt", value: 1000 },
+                  then: { decision: "approve", weight: 0.8, reason: "Low amount" }
+                },
+                {
+                  id: "high_amount_review",
+                  if: { field: "amount", op: "gte", value: 10000 },
+                  then: { decision: "manual_review", weight: 0.9, reason: "High amount requires review" }
+                }
+              ]
+            }
+          },
+          {
+            name: "User Access Control",
+            description: "Role-based access control rules",
+            rules: {
+              version: "1.0",
+              ruleset: "access_control",
+              rules: [
+                {
+                  id: "admin_full_access",
+                  if: {
+                    all: [
+                      { field: "user.role", op: "eq", value: "admin" },
+                      { field: "user.active", op: "eq", value: true }
+                    ]
+                  },
+                  then: { decision: "allow", weight: 1.0, reason: "Active admin user" }
+                },
+                {
+                  id: "guest_read_only",
+                  if: {
+                    all: [
+                      { field: "user.role", op: "eq", value: "guest" },
+                      { field: "action", op: "eq", value: "read" }
+                    ]
+                  },
+                  then: { decision: "allow", weight: 0.7, reason: "Guest read access" }
+                },
+                {
+                  id: "inactive_user_deny",
+                  if: { field: "user.active", op: "eq", value: false },
+                  then: { decision: "deny", weight: 1.0, reason: "Inactive user account" }
+                }
+              ]
+            }
+          },
+          {
+            name: "Content Moderation",
+            description: "Automatic content moderation rules",
+            rules: {
+              version: "1.0",
+              ruleset: "content_moderation",
+              rules: [
+                {
+                  id: "verified_user_approve",
+                  if: {
+                    all: [
+                      { field: "author.verified", op: "eq", value: true },
+                      { field: "content_length", op: "lt", value: 5000 }
+                    ]
+                  },
+                  then: { decision: "approve", weight: 0.85, reason: "Verified author with reasonable length" }
+                },
+                {
+                  id: "missing_content_reject",
+                  if: {
+                    any: [
+                      { field: "content", op: "blank" },
+                      { field: "content_length", op: "eq", value: 0 }
+                    ]
+                  },
+                  then: { decision: "reject", weight: 1.0, reason: "Empty content" }
+                },
+                {
+                  id: "flagged_content_review",
+                  if: { field: "flags", op: "present" },
+                  then: { decision: "manual_review", weight: 0.9, reason: "Content has been flagged" }
+                }
+              ]
+            }
+          }
+        ]
+
+        examples.to_json
+      end
+
+      # Health check
+      get "/health" do
+        content_type :json
+        { status: "ok", version: DecisionAgent::VERSION }.to_json
+      end
+
+      private
+
+      def parse_validation_errors(error_message)
+        # Extract individual errors from the formatted error message
+        errors = []
+
+        # The error message is formatted with numbered errors
+        lines = error_message.split("\n")
+
+        lines.each do |line|
+          # Match lines like "  1. Error message"
+          if line.match?(/^\s*\d+\.\s+/)
+            error = line.gsub(/^\s*\d+\.\s+/, "").strip
+            errors << error unless error.empty?
+          end
+        end
+
+        # If no errors were parsed, return the full message
+        errors.empty? ? [error_message] : errors
+      end
+
+      # Class method to start the server
+      def self.start!(port: 4567, host: "0.0.0.0")
+        set :port, port
+        set :bind, host
+        run!
+      end
+    end
+  end
+end

data/lib/decision_agent.rb

@@ -0,0 +1,29 @@
+require_relative "decision_agent/version"
+require_relative "decision_agent/errors"
+require_relative "decision_agent/context"
+require_relative "decision_agent/evaluation"
+require_relative "decision_agent/decision"
+require_relative "decision_agent/agent"
+
+require_relative "decision_agent/evaluators/base"
+require_relative "decision_agent/evaluators/static_evaluator"
+require_relative "decision_agent/evaluators/json_rule_evaluator"
+
+require_relative "decision_agent/dsl/schema_validator"
+require_relative "decision_agent/dsl/rule_parser"
+require_relative "decision_agent/dsl/condition_evaluator"
+
+require_relative "decision_agent/scoring/base"
+require_relative "decision_agent/scoring/weighted_average"
+require_relative "decision_agent/scoring/max_weight"
+require_relative "decision_agent/scoring/consensus"
+require_relative "decision_agent/scoring/threshold"
+
+require_relative "decision_agent/audit/adapter"
+require_relative "decision_agent/audit/null_adapter"
+require_relative "decision_agent/audit/logger_adapter"
+
+require_relative "decision_agent/replay/replay"
+
+module DecisionAgent
+end

data/spec/agent_spec.rb

@@ -0,0 +1,249 @@
+require "spec_helper"
+
+RSpec.describe DecisionAgent::Agent do
+  describe "#initialize" do
+    it "requires at least one evaluator" do
+      expect {
+        DecisionAgent::Agent.new(evaluators: [])
+      }.to raise_error(DecisionAgent::InvalidConfigurationError, /at least one evaluator/i)
+    end
+
+    it "validates evaluators respond to #evaluate" do
+      invalid_evaluator = Object.new
+
+      expect {
+        DecisionAgent::Agent.new(evaluators: [invalid_evaluator])
+      }.to raise_error(DecisionAgent::InvalidEvaluatorError)
+    end
+
+    it "validates scoring strategy responds to #score" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+      invalid_strategy = Object.new
+
+      expect {
+        DecisionAgent::Agent.new(
+          evaluators: [evaluator],
+          scoring_strategy: invalid_strategy
+        )
+      }.to raise_error(DecisionAgent::InvalidScoringStrategyError)
+    end
+
+    it "validates audit adapter responds to #record" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+      invalid_adapter = Object.new
+
+      expect {
+        DecisionAgent::Agent.new(
+          evaluators: [evaluator],
+          audit_adapter: invalid_adapter
+        )
+      }.to raise_error(DecisionAgent::InvalidAuditAdapterError)
+    end
+
+    it "uses defaults when optional parameters are omitted" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator])
+
+      expect(agent.scoring_strategy).to be_a(DecisionAgent::Scoring::WeightedAverage)
+      expect(agent.audit_adapter).to be_a(DecisionAgent::Audit::NullAdapter)
+    end
+  end
+
+  describe "#decide" do
+    it "returns a Decision object with all required fields" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "approve",
+        weight: 0.8,
+        reason: "Test approval"
+      )
+
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator])
+
+      result = agent.decide(context: { user: "test" })
+
+      expect(result).to be_a(DecisionAgent::Decision)
+      expect(result.decision).to eq("approve")
+      expect(result.confidence).to be_between(0.0, 1.0)
+      expect(result.explanations).to be_an(Array)
+      expect(result.evaluations).to be_an(Array)
+      expect(result.audit_payload).to be_a(Hash)
+    end
+
+    it "accepts Context object or Hash for context parameter" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator])
+
+      result1 = agent.decide(context: { user: "test" })
+      result2 = agent.decide(context: DecisionAgent::Context.new({ user: "test" }))
+
+      expect(result1.decision).to eq(result2.decision)
+    end
+
+    it "raises NoEvaluationsError when no evaluators return decisions" do
+      failing_evaluator = Class.new(DecisionAgent::Evaluators::Base) do
+        def evaluate(context, feedback: {})
+          nil
+        end
+      end
+
+      agent = DecisionAgent::Agent.new(evaluators: [failing_evaluator.new])
+
+      expect {
+        agent.decide(context: {})
+      }.to raise_error(DecisionAgent::NoEvaluationsError)
+    end
+
+    it "includes feedback in evaluation" do
+      feedback_evaluator = Class.new(DecisionAgent::Evaluators::Base) do
+        def evaluate(context, feedback: {})
+          decision = feedback[:override] ? "reject" : "approve"
+          DecisionAgent::Evaluation.new(
+            decision: decision,
+            weight: 1.0,
+            reason: "Feedback-based",
+            evaluator_name: "FeedbackEvaluator"
+          )
+        end
+      end
+
+      agent = DecisionAgent::Agent.new(evaluators: [feedback_evaluator.new])
+
+      result1 = agent.decide(context: {}, feedback: {})
+      result2 = agent.decide(context: {}, feedback: { override: true })
+
+      expect(result1.decision).to eq("approve")
+      expect(result2.decision).to eq("reject")
+    end
+
+    it "records decision via audit adapter" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+
+      audit_adapter = Class.new(DecisionAgent::Audit::Adapter) do
+        attr_reader :recorded_decision, :recorded_context
+
+        def record(decision, context)
+          @recorded_decision = decision
+          @recorded_context = context
+        end
+      end.new
+
+      agent = DecisionAgent::Agent.new(
+        evaluators: [evaluator],
+        audit_adapter: audit_adapter
+      )
+
+      result = agent.decide(context: { user: "test" })
+
+      expect(audit_adapter.recorded_decision).to eq(result)
+      expect(audit_adapter.recorded_context.to_h).to eq({ user: "test" })
+    end
+
+    it "includes deterministic hash in audit payload" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve", weight: 0.8)
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator])
+
+      result1 = agent.decide(context: { user: "test" })
+      result2 = agent.decide(context: { user: "test" })
+
+      expect(result1.audit_payload[:deterministic_hash]).to be_a(String)
+      expect(result1.audit_payload[:deterministic_hash]).to eq(result2.audit_payload[:deterministic_hash])
+    end
+
+    it "produces different hashes for different contexts" do
+      evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator])
+
+      result1 = agent.decide(context: { user: "alice" })
+      result2 = agent.decide(context: { user: "bob" })
+
+      expect(result1.audit_payload[:deterministic_hash]).not_to eq(result2.audit_payload[:deterministic_hash])
+    end
+  end
+
+  describe "conflict resolution" do
+    it "resolves conflicting evaluations using scoring strategy" do
+      evaluator1 = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "approve",
+        weight: 0.6,
+        name: "Evaluator1"
+      )
+      evaluator2 = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "reject",
+        weight: 0.9,
+        name: "Evaluator2"
+      )
+
+      agent = DecisionAgent::Agent.new(
+        evaluators: [evaluator1, evaluator2],
+        scoring_strategy: DecisionAgent::Scoring::MaxWeight.new
+      )
+
+      result = agent.decide(context: {})
+
+      expect(result.decision).to eq("reject")
+      expect(result.explanations.join(" ")).to include("Conflicting evaluations")
+    end
+
+    it "includes conflicting evaluations in explanations" do
+      evaluator1 = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "approve",
+        weight: 0.4,
+        name: "Evaluator1"
+      )
+      evaluator2 = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "reject",
+        weight: 0.7,
+        name: "Evaluator2"
+      )
+
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator1, evaluator2])
+
+      result = agent.decide(context: {})
+
+      explanations_text = result.explanations.join(" ")
+      expect(explanations_text).to include("Evaluator1")
+      expect(explanations_text).to include("Evaluator2")
+    end
+  end
+
+  describe "multiple evaluators agreeing" do
+    it "combines evaluations when all agree" do
+      evaluator1 = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "approve",
+        weight: 0.6,
+        name: "Evaluator1"
+      )
+      evaluator2 = DecisionAgent::Evaluators::StaticEvaluator.new(
+        decision: "approve",
+        weight: 0.8,
+        name: "Evaluator2"
+      )
+
+      agent = DecisionAgent::Agent.new(evaluators: [evaluator1, evaluator2])
+
+      result = agent.decide(context: {})
+
+      expect(result.decision).to eq("approve")
+      expect(result.confidence).to be > 0.5
+    end
+  end
+
+  describe "graceful error handling" do
+    it "ignores evaluators that raise errors" do
+      good_evaluator = DecisionAgent::Evaluators::StaticEvaluator.new(decision: "approve")
+
+      bad_evaluator = Class.new(DecisionAgent::Evaluators::Base) do
+        def evaluate(context, feedback: {})
+          raise StandardError, "Intentional error"
+        end
+      end
+
+      agent = DecisionAgent::Agent.new(evaluators: [bad_evaluator.new, good_evaluator])
+
+      result = agent.decide(context: {})
+
+      expect(result.decision).to eq("approve")
+    end
+  end
+end