decision_agent 0.1.7 → 0.3.0

data/lib/decision_agent/dmn/decision_graph.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require_relative "feel/evaluator"
+require_relative "errors"
+require_relative "decision_tree"
+
+module DecisionAgent
+  module Dmn
+    # Represents a decision in a decision graph
+    class DecisionNode
+      attr_reader :id, :name, :decision_logic, :information_requirements
+      attr_accessor :value, :evaluated
+
+      def initialize(id:, name:, decision_logic: nil)
+        @id = id
+        @name = name
+        @decision_logic = decision_logic # Can be DecisionTable, DecisionTree, or literal
+        @information_requirements = [] # Dependencies on other decisions
+        @value = nil
+        @evaluated = false
+      end
+
+      def add_dependency(decision_id, variable_name = nil)
+        @information_requirements << {
+          decision_id: decision_id,
+          variable_name: variable_name || decision_id
+        }
+      end
+
+      def depends_on?(decision_id)
+        @information_requirements.any? { |req| req[:decision_id] == decision_id }
+      end
+
+      def reset!
+        @value = nil
+        @evaluated = false
+      end
+
+      def to_h
+        {
+          id: @id,
+          name: @name,
+          information_requirements: @information_requirements,
+          decision_logic_type: decision_logic_type
+        }
+      end
+
+      private
+
+      def decision_logic_type
+        case @decision_logic
+        when DecisionTree
+          "decision_tree"
+        when Hash
+          "decision_table"
+        else
+          "literal"
+        end
+      end
+    end
+
+    # Represents and evaluates a decision graph (DMN model with multiple decisions)
+    class DecisionGraph
+      attr_reader :id, :name, :decisions
+
+      def initialize(id:, name:)
+        @id = id
+        @name = name
+        @decisions = {} # decision_id => DecisionNode
+        @feel_evaluator = Feel::Evaluator.new
+      end
+
+      def add_decision(decision)
+        @decisions[decision.id] = decision
+      end
+
+      def get_decision(decision_id)
+        @decisions[decision_id]
+      end
+
+      # Evaluate a specific decision (and all its dependencies)
+      def evaluate(decision_id, context)
+        decision = @decisions[decision_id]
+        raise DmnError, "Decision '#{decision_id}' not found" unless decision
+
+        # Reset all decision evaluations
+        reset_all!
+
+        # Build evaluation context
+        eval_context = context.is_a?(Hash) ? context : context.to_h
+
+        # Evaluate the requested decision (will recursively evaluate dependencies)
+        evaluate_decision(decision, eval_context)
+      end
+
+      # Evaluate all decisions in the graph
+      def evaluate_all(context)
+        reset_all!
+        eval_context = context.is_a?(Hash) ? context : context.to_h
+
+        results = {}
+        @decisions.each do |decision_id, decision|
+          results[decision_id] = evaluate_decision(decision, eval_context) unless decision.evaluated
+        end
+
+        results
+      end
+
+      # Get decisions in topological order (respecting dependencies)
+      def topological_order
+        order = []
+        visited = Set.new
+        temp_mark = Set.new
+
+        visit = lambda do |decision_id|
+          return if visited.include?(decision_id)
+
+          raise DmnError, "Circular dependency detected involving decision '#{decision_id}'" if temp_mark.include?(decision_id)
+
+          temp_mark.add(decision_id)
+
+          decision = @decisions[decision_id]
+          decision.information_requirements.each do |req|
+            visit.call(req[:decision_id]) if @decisions[req[:decision_id]]
+          end
+
+          temp_mark.delete(decision_id)
+          visited.add(decision_id)
+          order << decision_id
+        end
+
+        @decisions.each_key { |decision_id| visit.call(decision_id) }
+        order
+      end
+
+      # Detect circular dependencies
+      def circular_dependencies?
+        topological_order
+        false
+      rescue DmnError => e
+        e.message.include?("Circular dependency")
+      end
+
+      # Get all leaf decisions (no other decisions depend on them)
+      def leaf_decisions
+        dependent_decisions = Set.new
+        @decisions.each_value do |decision|
+          decision.information_requirements.each do |req|
+            dependent_decisions.add(req[:decision_id])
+          end
+        end
+
+        @decisions.keys.reject { |id| dependent_decisions.include?(id) }
+      end
+
+      # Get all root decisions (don't depend on other decisions)
+      def root_decisions
+        @decisions.select { |_id, decision| decision.information_requirements.empty? }.keys
+      end
+
+      # Get the dependency graph as a hash
+      def dependency_graph
+        graph = {}
+        @decisions.each do |id, decision|
+          graph[id] = decision.information_requirements.map { |req| req[:decision_id] }
+        end
+        graph
+      end
+
+      # Export graph structure
+      def to_h
+        {
+          id: @id,
+          name: @name,
+          decisions: @decisions.transform_values(&:to_h),
+          dependency_graph: dependency_graph
+        }
+      end
+
+      private
+
+      def reset_all!
+        @decisions.each_value(&:reset!)
+      end
+
+      def evaluate_decision(decision, context)
+        # If already evaluated, return cached value
+        return decision.value if decision.evaluated
+
+        # First, evaluate all dependencies
+        decision.information_requirements.each do |req|
+          dep_decision = @decisions[req[:decision_id]]
+          next unless dep_decision
+
+          # Recursively evaluate dependency
+          dep_value = evaluate_decision(dep_decision, context)
+
+          # Add dependency result to context with the specified variable name
+          context[req[:variable_name]] = dep_value
+        end
+
+        # Now evaluate this decision with the enriched context
+        decision.value = evaluate_decision_logic(decision, context)
+        decision.evaluated = true
+        decision.value
+      end
+
+      def evaluate_decision_logic(decision, context)
+        case decision.decision_logic
+        when DecisionTree
+          # Evaluate decision tree
+          decision.decision_logic.evaluate(context)
+        when Hash
+          # Evaluate decision table (simplified)
+          evaluate_decision_table(decision.decision_logic, context)
+        when String
+          # Evaluate as FEEL expression (literal expression)
+          @feel_evaluator.evaluate(decision.decision_logic, "result", context)
+        when Proc
+          # Execute custom logic with string keys
+          string_context = context.transform_keys(&:to_s)
+          decision.decision_logic.call(string_context)
+        else
+          # Return as-is
+          decision.decision_logic
+        end
+      rescue StandardError => e
+        raise DmnError, "Failed to evaluate decision '#{decision.id}': #{e.message}"
+      end
+
+      def evaluate_decision_table(table, context)
+        # Simplified decision table evaluation
+        # In a full implementation, this would delegate to the DecisionTable evaluator
+        rules = table[:rules] || []
+
+        matching_rule = rules.find do |rule|
+          rule[:conditions].all? do |input_id, condition|
+            value = context[input_id]
+            evaluate_condition(condition, value, context)
+          end
+        end
+
+        matching_rule ? matching_rule[:output] : nil
+      end
+
+      def evaluate_condition(condition, value, context)
+        return true if condition.nil? || condition == "-"
+
+        @feel_evaluator.evaluate(
+          "#{value} #{condition}",
+          "condition",
+          context
+        )
+      rescue StandardError
+        false
+      end
+    end
+
+    # Parser for DMN decision graphs from XML
+    class DecisionGraphParser
+      def self.parse(xml_doc)
+        # Extract namespace and model info
+        definitions = xml_doc.at_xpath("//dmn:definitions") || xml_doc.root
+        model_id = definitions["id"] || "decision_graph"
+        model_name = definitions["name"] || model_id
+
+        graph = DecisionGraph.new(id: model_id, name: model_name)
+
+        # Parse all decisions
+        decisions = xml_doc.xpath("//dmn:decision")
+        decisions.each do |decision_xml|
+          decision_node = parse_decision_node(decision_xml)
+          graph.add_decision(decision_node)
+
+          # Parse information requirements (dependencies)
+          decision_id = decision_xml["id"]
+          decision_node = graph.get_decision(decision_id)
+
+          # Find all information requirements
+          info_reqs = decision_xml.xpath(".//dmn:informationRequirement")
+          info_reqs.each do |req|
+            required_decision = req.at_xpath(".//dmn:requiredDecision")
+            if required_decision
+              required_id = required_decision["href"]&.sub("#", "")
+              decision_node.add_dependency(required_id) if required_id
+            end
+          end
+        end
+
+        graph
+      end
+
+      def self.parse_decision_node(decision_xml)
+        decision_id = decision_xml["id"]
+        decision_name = decision_xml["name"] || decision_id
+
+        # Check for decision table
+        decision_table = decision_xml.at_xpath(".//dmn:decisionTable")
+        if decision_table
+          # Parse decision table (simplified)
+          decision_logic = parse_decision_table(decision_table)
+        else
+          # Check for literal expression (could be decision tree or simple expression)
+          literal_expr = decision_xml.at_xpath(".//dmn:literalExpression")
+          decision_logic = literal_expr&.text&.strip
+        end
+
+        DecisionNode.new(
+          id: decision_id,
+          name: decision_name,
+          decision_logic: decision_logic
+        )
+      end
+
+      def self.parse_decision_table(table_xml)
+        # Simplified decision table parsing
+        # Full implementation would use the existing DecisionTable parser
+        {
+          type: "decision_table",
+          hit_policy: table_xml["hitPolicy"] || "UNIQUE",
+          inputs: [],
+          rules: []
+        }
+      end
+    end
+  end
+end

data/lib/decision_agent/dmn/decision_tree.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative "feel/evaluator"
+require_relative "errors"
+
+module DecisionAgent
+  module Dmn
+    # Represents a node in a decision tree
+    class TreeNode
+      attr_reader :id, :label, :condition, :decision, :children
+      attr_accessor :parent
+
+      def initialize(id:, label: nil, condition: nil, decision: nil)
+        @id = id
+        @label = label
+        @condition = condition # FEEL expression to evaluate
+        @decision = decision   # Output decision if this is a leaf node
+        @children = []
+        @parent = nil
+      end
+
+      def add_child(node)
+        node.parent = self
+        @children << node
+      end
+
+      def leaf?
+        @children.empty?
+      end
+
+      def to_h
+        {
+          id: @id,
+          label: @label,
+          condition: @condition,
+          decision: @decision,
+          children: @children.map(&:to_h)
+        }
+      end
+    end
+
+    # Evaluates decision trees
+    class DecisionTree
+      attr_reader :id, :name, :root
+
+      def initialize(id:, name:, root: nil)
+        @id = id
+        @name = name
+        @root = root || TreeNode.new(id: "root", label: "Root")
+        @feel_evaluator = Feel::Evaluator.new
+      end
+
+      # Evaluate the decision tree with given context
+      def evaluate(context)
+        traverse(@root, context)
+      end
+
+      # Build a decision tree from a hash representation
+      def self.from_hash(hash)
+        tree = new(id: hash[:id], name: hash[:name])
+        tree.instance_variable_set(:@root, build_node(hash[:root]))
+        tree
+      end
+
+      # Convert tree to hash representation
+      def to_h
+        {
+          id: @id,
+          name: @name,
+          root: @root.to_h
+        }
+      end
+
+      # Get all leaf nodes (decision outcomes)
+      def leaf_nodes
+        collect_leaf_nodes(@root)
+      end
+
+      # Get tree depth
+      def depth
+        calculate_depth(@root)
+      end
+
+      # Get all paths from root to leaves
+      def paths
+        collect_paths(@root, [])
+      end
+
+      private
+
+      def traverse(node, context)
+        # If this is a leaf node, return the decision
+        return node.decision if node.leaf?
+
+        # Track if any condition was successfully evaluated
+        any_condition_evaluated = false
+        has_children_with_conditions = node.children.any?(&:condition)
+
+        # Evaluate each child's condition until we find a match
+        node.children.each do |child|
+          next unless child.condition
+
+          begin
+            result = @feel_evaluator.evaluate(child.condition, "condition", context.to_h)
+            any_condition_evaluated = true
+
+            return traverse(child, context) if result
+            # Condition matched, continue down this branch
+
+            # Condition evaluated to false - check if this child has a false branch
+            # If child has multiple leaf children with no conditions, take the second one
+            if !child.leaf? && child.children.all? { |c| c.condition.nil? && c.leaf? } && child.children.size > 1
+              return child.children[1].decision
+            end
+          rescue StandardError
+            # If condition evaluation fails, skip this branch
+            next
+          end
+        end
+
+        # No matching condition found, check for a default branch (no condition)
+        # Take default if: no children have conditions, OR at least one condition was successfully evaluated
+        if !has_children_with_conditions || any_condition_evaluated
+          default_child = node.children.find { |c| c.condition.nil? }
+          return traverse(default_child, context) if default_child
+        end
+
+        # No match found
+        nil
+      end
+
+      def self.build_node(hash)
+        node = TreeNode.new(
+          id: hash[:id],
+          label: hash[:label],
+          condition: hash[:condition],
+          decision: hash[:decision]
+        )
+
+        hash[:children]&.each do |child_hash|
+          node.add_child(build_node(child_hash))
+        end
+
+        node
+      end
+
+      def collect_leaf_nodes(node, leaves = [])
+        if node.leaf?
+          leaves << node
+        else
+          node.children.each { |child| collect_leaf_nodes(child, leaves) }
+        end
+        leaves
+      end
+
+      def calculate_depth(node, current_depth = 0)
+        return current_depth if node.leaf?
+
+        max_child_depth = node.children.map { |child| calculate_depth(child, current_depth + 1) }.max
+        max_child_depth || current_depth
+      end
+
+      def collect_paths(node, current_path, paths = [])
+        current_path += [node]
+
+        if node.leaf?
+          paths << current_path
+        else
+          node.children.each { |child| collect_paths(child, current_path, paths) }
+        end
+
+        paths
+      end
+    end
+
+    # Parser for DMN decision trees (literal expressions)
+    class DecisionTreeParser
+      def self.parse(xml_element)
+        # Parse DMN literal expression (decision tree representation)
+        # This is a simplified parser - full DMN tree parsing would be more complex
+        tree_id = xml_element["id"]
+        tree_name = xml_element["name"] || tree_id
+
+        DecisionTree.new(id: tree_id, name: tree_name)
+
+        # Parse the tree structure from XML
+        # Note: This is a placeholder for full DMN literal expression parsing
+        # In a complete implementation, this would parse the DMN tree structure
+      end
+    end
+  end
+end

data/lib/decision_agent/dmn/errors.rb

@@ -0,0 +1,30 @@
+module DecisionAgent
+  module Dmn
+    # Base error for all DMN-related errors
+    class DmnError < StandardError; end
+
+    # Raised when DMN XML is invalid or malformed
+    class InvalidDmnXmlError < DmnError; end
+
+    # Raised when DMN model structure is invalid
+    class InvalidDmnModelError < DmnError; end
+
+    # Raised when hit policy is unsupported
+    class UnsupportedHitPolicyError < DmnError; end
+
+    # Raised when FEEL expression cannot be parsed
+    class FeelParseError < DmnError; end
+
+    # Raised when parse tree transformation to AST fails
+    class FeelTransformError < DmnError; end
+
+    # Raised when FEEL expression evaluation fails
+    class FeelEvaluationError < DmnError; end
+
+    # Raised when type conversion or type checking fails
+    class FeelTypeError < DmnError; end
+
+    # Raised when a function is not found or has invalid arguments
+    class FeelFunctionError < DmnError; end
+  end
+end