decision_agent 0.3.0 → 1.1.0

data/spec/dmn/decision_graph_spec.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "decision_agent/dmn/decision_graph"
-
-RSpec.describe DecisionAgent::Dmn::DecisionGraph do
-  describe "graph construction" do
-    let(:graph) do
-      described_class.new(id: "graph1", name: "Test Graph")
-    end
-
-    it "creates an empty graph" do
-      expect(graph.decisions).to be_empty
-    end
-
-    it "adds decisions to the graph" do
-      decision = DecisionAgent::Dmn::DecisionNode.new(
-        id: "decision1",
-        name: "First Decision"
-      )
-      graph.add_decision(decision)
-
-      expect(graph.decisions["decision1"]).to eq(decision)
-    end
-
-    it "retrieves decisions by id" do
-      decision = DecisionAgent::Dmn::DecisionNode.new(id: "decision1", name: "Test")
-      graph.add_decision(decision)
-
-      retrieved = graph.get_decision("decision1")
-      expect(retrieved).to eq(decision)
-    end
-  end
-
-  describe "decision dependencies" do
-    let(:graph) do
-      graph = described_class.new(id: "dep_graph", name: "Dependency Graph")
-
-      # Create decisions
-      decision1 = DecisionAgent::Dmn::DecisionNode.new(
-        id: "base_rate",
-        name: "Base Rate",
-        decision_logic: 0.05
-      )
-
-      decision2 = DecisionAgent::Dmn::DecisionNode.new(
-        id: "risk_adjustment",
-        name: "Risk Adjustment",
-        decision_logic: 0.02
-      )
-
-      decision3 = DecisionAgent::Dmn::DecisionNode.new(
-        id: "final_rate",
-        name: "Final Rate",
-        decision_logic: ->(context) { context["base_rate"] + context["risk_adjustment"] }
-      )
-
-      # Add dependencies
-      decision3.add_dependency("base_rate")
-      decision3.add_dependency("risk_adjustment")
-
-      graph.add_decision(decision1)
-      graph.add_decision(decision2)
-      graph.add_decision(decision3)
-
-      graph
-    end
-
-    it "tracks decision dependencies" do
-      decision = graph.get_decision("final_rate")
-      expect(decision.information_requirements.length).to eq(2)
-      expect(decision.depends_on?("base_rate")).to be true
-      expect(decision.depends_on?("risk_adjustment")).to be true
-    end
-
-    it "evaluates decision with dependencies" do
-      result = graph.evaluate("final_rate", {})
-      expect(result).to eq(0.07) # 0.05 + 0.02
-    end
-  end
-
-  describe "topological ordering" do
-    let(:graph) do
-      graph = described_class.new(id: "topo_graph", name: "Topological Graph")
-
-      # Create a dependency chain: A -> B -> C
-      decision_a = DecisionAgent::Dmn::DecisionNode.new(id: "a", name: "A", decision_logic: 1)
-      decision_b = DecisionAgent::Dmn::DecisionNode.new(id: "b", name: "B", decision_logic: ->(ctx) { ctx["a"] + 1 })
-      decision_c = DecisionAgent::Dmn::DecisionNode.new(id: "c", name: "C", decision_logic: ->(ctx) { ctx["b"] + 1 })
-
-      decision_b.add_dependency("a")
-      decision_c.add_dependency("b")
-
-      graph.add_decision(decision_a)
-      graph.add_decision(decision_b)
-      graph.add_decision(decision_c)
-
-      graph
-    end
-
-    it "returns decisions in topological order" do
-      order = graph.topological_order
-      expect(order.index("a")).to be < order.index("b")
-      expect(order.index("b")).to be < order.index("c")
-    end
-
-    it "identifies root decisions" do
-      roots = graph.root_decisions
-      expect(roots).to eq(["a"])
-    end
-
-    it "identifies leaf decisions" do
-      leaves = graph.leaf_decisions
-      expect(leaves).to eq(["c"])
-    end
-  end
-
-  describe "circular dependency detection" do
-    it "detects circular dependencies" do
-      graph = described_class.new(id: "circular", name: "Circular Graph")
-
-      decision_a = DecisionAgent::Dmn::DecisionNode.new(id: "a", name: "A")
-      decision_b = DecisionAgent::Dmn::DecisionNode.new(id: "b", name: "B")
-
-      decision_a.add_dependency("b")
-      decision_b.add_dependency("a")
-
-      graph.add_decision(decision_a)
-      graph.add_decision(decision_b)
-
-      expect(graph.circular_dependencies?).to be true
-    end
-
-    it "raises error when evaluating circular dependencies" do
-      graph = described_class.new(id: "circular", name: "Circular Graph")
-
-      decision_a = DecisionAgent::Dmn::DecisionNode.new(id: "a", name: "A")
-      decision_b = DecisionAgent::Dmn::DecisionNode.new(id: "b", name: "B")
-
-      decision_a.add_dependency("b")
-      decision_b.add_dependency("a")
-
-      graph.add_decision(decision_a)
-      graph.add_decision(decision_b)
-
-      expect { graph.topological_order }.to raise_error(DecisionAgent::Dmn::DmnError, /Circular dependency/)
-    end
-  end
-
-  describe "complex graph evaluation" do
-    let(:graph) do
-      # Build a loan approval graph
-      # Decisions: income_check -> credit_check -> final_decision
-      graph = described_class.new(id: "loan_graph", name: "Loan Approval Graph")
-
-      income_check = DecisionAgent::Dmn::DecisionNode.new(
-        id: "income_check",
-        name: "Income Check",
-        decision_logic: ->(ctx) { ctx["income"] >= 50_000 ? "sufficient" : "insufficient" }
-      )
-
-      credit_check = DecisionAgent::Dmn::DecisionNode.new(
-        id: "credit_check",
-        name: "Credit Check",
-        decision_logic: ->(ctx) { ctx["credit_score"] >= 650 ? "good" : "poor" }
-      )
-
-      final_decision = DecisionAgent::Dmn::DecisionNode.new(
-        id: "final_decision",
-        name: "Final Decision",
-        decision_logic: lambda do |ctx|
-          if ctx["income_check"] == "sufficient" && ctx["credit_check"] == "good"
-            "Approved"
-          else
-            "Rejected"
-          end
-        end
-      )
-
-      final_decision.add_dependency("income_check", "income_check")
-      final_decision.add_dependency("credit_check", "credit_check")
-
-      graph.add_decision(income_check)
-      graph.add_decision(credit_check)
-      graph.add_decision(final_decision)
-
-      graph
-    end
-
-    it "evaluates graph with all dependencies for approved case" do
-      context = { income: 60_000, credit_score: 700 }
-      result = graph.evaluate("final_decision", context)
-      expect(result).to eq("Approved")
-    end
-
-    it "evaluates graph with all dependencies for rejected case" do
-      context = { income: 40_000, credit_score: 600 }
-      result = graph.evaluate("final_decision", context)
-      expect(result).to eq("Rejected")
-    end
-
-    it "evaluates all decisions in graph" do
-      context = { income: 60_000, credit_score: 700 }
-      results = graph.evaluate_all(context)
-
-      expect(results["income_check"]).to eq("sufficient")
-      expect(results["credit_check"]).to eq("good")
-      expect(results["final_decision"]).to eq("Approved")
-    end
-  end
-
-  describe "graph analysis" do
-    let(:graph) do
-      graph = described_class.new(id: "analysis", name: "Analysis Graph")
-
-      d1 = DecisionAgent::Dmn::DecisionNode.new(id: "d1", name: "D1", decision_logic: 1)
-      d2 = DecisionAgent::Dmn::DecisionNode.new(id: "d2", name: "D2", decision_logic: 2)
-      d3 = DecisionAgent::Dmn::DecisionNode.new(id: "d3", name: "D3", decision_logic: 3)
-
-      d3.add_dependency("d1")
-      d3.add_dependency("d2")
-
-      graph.add_decision(d1)
-      graph.add_decision(d2)
-      graph.add_decision(d3)
-
-      graph
-    end
-
-    it "exports dependency graph structure" do
-      dep_graph = graph.dependency_graph
-      expect(dep_graph["d1"]).to eq([])
-      expect(dep_graph["d2"]).to eq([])
-      expect(dep_graph["d3"]).to contain_exactly("d1", "d2")
-    end
-
-    it "exports graph to hash representation" do
-      hash = graph.to_h
-      expect(hash[:id]).to eq("analysis")
-      expect(hash[:name]).to eq("Analysis Graph")
-      expect(hash[:decisions].keys).to contain_exactly("d1", "d2", "d3")
-      expect(hash[:dependency_graph]).to be_a(Hash)
-    end
-  end
-
-  describe DecisionAgent::Dmn::DecisionNode do
-    it "creates decision node with basic attributes" do
-      node = described_class.new(id: "test", name: "Test Decision")
-      expect(node.id).to eq("test")
-      expect(node.name).to eq("Test Decision")
-      expect(node.information_requirements).to be_empty
-    end
-
-    it "adds dependencies" do
-      node = described_class.new(id: "test", name: "Test")
-      node.add_dependency("dep1", "variable1")
-
-      expect(node.information_requirements.length).to eq(1)
-      expect(node.information_requirements.first[:decision_id]).to eq("dep1")
-      expect(node.information_requirements.first[:variable_name]).to eq("variable1")
-    end
-
-    it "checks if node depends on another decision" do
-      node = described_class.new(id: "test", name: "Test")
-      node.add_dependency("dep1")
-
-      expect(node.depends_on?("dep1")).to be true
-      expect(node.depends_on?("dep2")).to be false
-    end
-
-    it "resets evaluation state" do
-      node = described_class.new(id: "test", name: "Test")
-      node.value = "some value"
-      node.evaluated = true
-
-      node.reset!
-
-      expect(node.value).to be_nil
-      expect(node.evaluated).to be false
-    end
-  end
-end

data/spec/dmn/decision_tree_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "decision_agent/dmn/decision_tree"
-
-RSpec.describe DecisionAgent::Dmn::DecisionTree do
-  describe "basic tree structure" do
-    let(:tree) do
-      described_class.new(id: "tree1", name: "Loan Approval Tree")
-    end
-
-    it "creates a tree with root node" do
-      expect(tree.root).to be_a(DecisionAgent::Dmn::TreeNode)
-      expect(tree.root.id).to eq("root")
-    end
-
-    it "allows adding children to nodes" do
-      child1 = DecisionAgent::Dmn::TreeNode.new(id: "child1", label: "Check Age")
-      tree.root.add_child(child1)
-
-      expect(tree.root.children).to include(child1)
-      expect(child1.parent).to eq(tree.root)
-    end
-  end
-
-  describe "tree evaluation" do
-    let(:tree) do
-      # Build a simple decision tree for loan approval
-      tree = described_class.new(id: "loan_tree", name: "Loan Approval")
-
-      # Root node
-      root = tree.root
-
-      # First level - check age
-      age_check = DecisionAgent::Dmn::TreeNode.new(
-        id: "age_check",
-        label: "Age >= 18?",
-        condition: "age >= 18"
-      )
-      root.add_child(age_check)
-
-      # Second level under age check - check credit score
-      good_credit = DecisionAgent::Dmn::TreeNode.new(
-        id: "good_credit",
-        label: "Credit Score >= 650?",
-        condition: "credit_score >= 650"
-      )
-      age_check.add_child(good_credit)
-
-      # Leaf nodes - decisions
-      approved = DecisionAgent::Dmn::TreeNode.new(
-        id: "approved",
-        label: "Approved",
-        decision: "Approved"
-      )
-      good_credit.add_child(approved)
-
-      rejected_credit = DecisionAgent::Dmn::TreeNode.new(
-        id: "rejected_credit",
-        label: "Rejected - Poor Credit",
-        decision: "Rejected - Poor Credit"
-      )
-      good_credit.add_child(rejected_credit)
-
-      # Rejected for age
-      rejected_age = DecisionAgent::Dmn::TreeNode.new(
-        id: "rejected_age",
-        label: "Rejected - Too Young",
-        decision: "Rejected - Too Young"
-      )
-      root.add_child(rejected_age)
-
-      tree
-    end
-
-    it "evaluates tree with context matching approved path" do
-      context = { age: 25, credit_score: 700 }
-      result = tree.evaluate(context)
-      expect(result).to eq("Approved")
-    end
-
-    it "evaluates tree with poor credit" do
-      context = { age: 25, credit_score: 600 }
-      result = tree.evaluate(context)
-      expect(result).to eq("Rejected - Poor Credit")
-    end
-
-    it "evaluates tree with age too young" do
-      context = { age: 16, credit_score: 700 }
-      result = tree.evaluate(context)
-      expect(result).to eq("Rejected - Too Young")
-    end
-
-    it "returns nil when no path matches" do
-      context = {}
-      result = tree.evaluate(context)
-      expect(result).to be_nil
-    end
-  end
-
-  describe "tree serialization" do
-    let(:tree_hash) do
-      {
-        id: "test_tree",
-        name: "Test Tree",
-        root: {
-          id: "root",
-          label: "Root",
-          condition: nil,
-          decision: nil,
-          children: [
-            {
-              id: "node1",
-              label: "Node 1",
-              condition: "x > 5",
-              decision: nil,
-              children: [
-                {
-                  id: "leaf1",
-                  label: "Leaf 1",
-                  condition: nil,
-                  decision: "Result A",
-                  children: []
-                }
-              ]
-            }
-          ]
-        }
-      }
-    end
-
-    it "converts tree to hash" do
-      tree = described_class.new(id: "tree1", name: "Tree 1")
-      node1 = DecisionAgent::Dmn::TreeNode.new(id: "node1", condition: "x > 5")
-      tree.root.add_child(node1)
-
-      hash = tree.to_h
-      expect(hash[:id]).to eq("tree1")
-      expect(hash[:name]).to eq("Tree 1")
-      expect(hash[:root][:children].length).to eq(1)
-    end
-
-    it "builds tree from hash" do
-      tree = described_class.from_hash(tree_hash)
-
-      expect(tree.id).to eq("test_tree")
-      expect(tree.name).to eq("Test Tree")
-      expect(tree.root.children.length).to eq(1)
-      expect(tree.root.children.first.id).to eq("node1")
-    end
-  end
-
-  describe "tree analysis" do
-    let(:tree) do
-      tree = described_class.new(id: "analysis_tree", name: "Analysis Tree")
-
-      level1 = DecisionAgent::Dmn::TreeNode.new(id: "level1")
-      tree.root.add_child(level1)
-
-      level2a = DecisionAgent::Dmn::TreeNode.new(id: "level2a")
-      level2b = DecisionAgent::Dmn::TreeNode.new(id: "level2b")
-      level1.add_child(level2a)
-      level1.add_child(level2b)
-
-      leaf1 = DecisionAgent::Dmn::TreeNode.new(id: "leaf1", decision: "Result 1")
-      leaf2 = DecisionAgent::Dmn::TreeNode.new(id: "leaf2", decision: "Result 2")
-      level2a.add_child(leaf1)
-      level2b.add_child(leaf2)
-
-      tree
-    end
-
-    it "collects all leaf nodes" do
-      leaves = tree.leaf_nodes
-      expect(leaves.length).to eq(2)
-      expect(leaves.map(&:id)).to include("leaf1", "leaf2")
-    end
-
-    it "calculates tree depth" do
-      expect(tree.depth).to eq(3) # root -> level1 -> level2 -> leaf (depth 3)
-    end
-
-    it "collects all paths from root to leaves" do
-      paths = tree.paths
-      expect(paths.length).to eq(2)
-      expect(paths.first.length).to be >= 3
-    end
-  end
-
-  describe DecisionAgent::Dmn::TreeNode do
-    it "identifies leaf nodes correctly" do
-      node = DecisionAgent::Dmn::TreeNode.new(id: "test", decision: "Decision")
-      expect(node.leaf?).to be true
-    end
-
-    it "identifies non-leaf nodes correctly" do
-      node = DecisionAgent::Dmn::TreeNode.new(id: "test")
-      child = DecisionAgent::Dmn::TreeNode.new(id: "child")
-      node.add_child(child)
-      expect(node.leaf?).to be false
-    end
-  end
-end

data/spec/dmn/feel/errors_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-require "decision_agent/dmn/errors"
-
-RSpec.describe "FEEL Errors" do
-  describe DecisionAgent::Dmn::FeelParseError do
-    it "creates error with message only" do
-      error = DecisionAgent::Dmn::FeelParseError.new("Parse failed")
-      expect(error.message).to eq("Parse failed")
-    end
-  end
-
-  describe DecisionAgent::Dmn::FeelEvaluationError do
-    it "creates error with message only" do
-      error = DecisionAgent::Dmn::FeelEvaluationError.new("Evaluation failed")
-      expect(error.message).to eq("Evaluation failed")
-    end
-  end
-end