decision_agent 0.2.0 → 0.3.0

data/lib/decision_agent/evaluators/dmn_evaluator.rb

@@ -0,0 +1,221 @@
+require_relative "../dmn/adapter"
+require_relative "../dmn/errors"
+require_relative "base"
+require_relative "json_rule_evaluator"
+
+module DecisionAgent
+  module Evaluators
+    # Evaluates DMN decision models
+    class DmnEvaluator < Base
+      attr_reader :model, :decision_id
+
+      def initialize(model:, decision_id:, name: nil)
+        @model = model
+        @decision_id = decision_id.to_s
+        @name = name || "DmnEvaluator(#{@decision_id})"
+
+        # Find and validate decision
+        @decision = @model.find_decision(@decision_id)
+        raise Dmn::InvalidDmnModelError, "Decision '#{@decision_id}' not found" unless @decision
+        raise Dmn::InvalidDmnModelError, "Decision '#{@decision_id}' has no decision table" unless @decision.decision_table
+
+        # Convert to JSON rules for execution
+        adapter = Dmn::Adapter.new(@decision.decision_table)
+        @rules_json = adapter.to_json_rules
+
+        # Create internal JSON rule evaluator
+        @json_evaluator = JsonRuleEvaluator.new(
+          rules_json: @rules_json,
+          name: @name
+        )
+
+        # Freeze for thread safety
+        @model.freeze
+        @decision_id.freeze
+        @name.freeze
+        freeze
+      end
+
+      def evaluate(context, feedback: {})
+        hit_policy = @decision.decision_table.hit_policy
+
+        # Short-circuit for FIRST and PRIORITY policies
+        if %w[FIRST PRIORITY].include?(hit_policy)
+          first_match = find_first_matching_evaluation(context, feedback: feedback)
+          return first_match if first_match
+
+          # If no match found, return nil (consistent with apply_first_policy behavior)
+          return nil
+        end
+
+        # For UNIQUE, ANY, COLLECT - need all matches
+        matching_evaluations = find_all_matching_evaluations(context, feedback: feedback)
+
+        # Apply hit policy to select the appropriate evaluation
+        apply_hit_policy(matching_evaluations)
+      end
+
+      private
+
+      def evaluator_name
+        @name
+      end
+
+      # Find first matching rule (for short-circuiting)
+      def find_first_matching_evaluation(context, feedback: {})
+        ctx = context.is_a?(Context) ? context : Context.new(context)
+        rules = @rules_json["rules"] || []
+
+        rules.each do |rule|
+          if_clause = rule["if"]
+          next unless if_clause
+
+          next unless Dsl::ConditionEvaluator.evaluate(if_clause, ctx)
+
+          then_clause = rule["then"]
+          return Evaluation.new(
+            decision: then_clause["decision"],
+            weight: then_clause["weight"] || 1.0,
+            reason: then_clause["reason"] || "Rule matched",
+            evaluator_name: @name,
+            metadata: {
+              type: "dmn_rule",
+              rule_id: rule["id"],
+              ruleset: @rules_json["ruleset"],
+              hit_policy: @decision.decision_table.hit_policy
+            }
+          )
+        end
+
+        nil
+      end
+
+      # Find all matching rules (not just first)
+      def find_all_matching_evaluations(context, feedback: {})
+        ctx = context.is_a?(Context) ? context : Context.new(context)
+        rules = @rules_json["rules"] || []
+        matching = []
+
+        rules.each do |rule|
+          if_clause = rule["if"]
+          next unless if_clause
+
+          next unless Dsl::ConditionEvaluator.evaluate(if_clause, ctx)
+
+          then_clause = rule["then"]
+          matching << Evaluation.new(
+            decision: then_clause["decision"],
+            weight: then_clause["weight"] || 1.0,
+            reason: then_clause["reason"] || "Rule matched",
+            evaluator_name: @name,
+            metadata: {
+              type: "dmn_rule",
+              rule_id: rule["id"],
+              ruleset: @rules_json["ruleset"],
+              hit_policy: @decision.decision_table.hit_policy
+            }
+          )
+        end
+
+        matching
+      end
+
+      # Apply hit policy to matching evaluations
+      def apply_hit_policy(matching_evaluations)
+        hit_policy = @decision.decision_table.hit_policy
+
+        case hit_policy
+        when "UNIQUE"
+          apply_unique_policy(matching_evaluations)
+        when "FIRST"
+          apply_first_policy(matching_evaluations)
+        when "PRIORITY"
+          apply_priority_policy(matching_evaluations)
+        when "ANY"
+          apply_any_policy(matching_evaluations)
+        when "COLLECT"
+          apply_collect_policy(matching_evaluations)
+        else
+          # Default to FIRST if unknown policy
+          apply_first_policy(matching_evaluations)
+        end
+      end
+
+      # UNIQUE: Exactly one rule must match
+      def apply_unique_policy(matching_evaluations)
+        case matching_evaluations.size
+        when 0
+          raise Dmn::InvalidDmnModelError,
+                "UNIQUE hit policy requires exactly one matching rule, but none matched"
+        when 1
+          matching_evaluations.first
+        else
+          rule_ids = matching_evaluations.map { |e| e.metadata[:rule_id] }.join(", ")
+          raise Dmn::InvalidDmnModelError,
+                "UNIQUE hit policy requires exactly one matching rule, but #{matching_evaluations.size} matched: #{rule_ids}"
+        end
+      end
+
+      # FIRST: Return first matching rule (already in order)
+      def apply_first_policy(matching_evaluations)
+        return nil if matching_evaluations.empty?
+
+        matching_evaluations.first
+      end
+
+      # PRIORITY: Return rule with highest priority
+      # For now, we use rule order as priority (first rule = highest priority)
+      # In full DMN spec, outputs can have priority values defined
+      def apply_priority_policy(matching_evaluations)
+        return nil if matching_evaluations.empty?
+
+        # For now, return first match (rules are already in priority order)
+        # Future enhancement: check output priority values if defined
+        matching_evaluations.first
+      end
+
+      # ANY: All matching rules must have same output
+      def apply_any_policy(matching_evaluations)
+        return nil if matching_evaluations.empty?
+
+        # Check that all decisions are the same
+        first_decision = matching_evaluations.first.decision
+        all_same = matching_evaluations.all? { |e| e.decision == first_decision }
+
+        unless all_same
+          decisions = matching_evaluations.map(&:decision).uniq.join(", ")
+          rule_ids = matching_evaluations.map { |e| e.metadata[:rule_id] }.join(", ")
+          raise Dmn::InvalidDmnModelError,
+                "ANY hit policy requires all matching rules to have the same output, " \
+                "but found different outputs: #{decisions} (rules: #{rule_ids})"
+        end
+
+        matching_evaluations.first
+      end
+
+      # COLLECT: Return all matching rules
+      # Since Evaluation expects a single decision, we'll return the first one
+      # but include metadata about all matches
+      def apply_collect_policy(matching_evaluations)
+        return nil if matching_evaluations.empty?
+
+        # Return first evaluation but include all matches in metadata
+        first = matching_evaluations.first
+        all_decisions = matching_evaluations.map(&:decision)
+        all_rule_ids = matching_evaluations.map { |e| e.metadata[:rule_id] }
+
+        Evaluation.new(
+          decision: first.decision,
+          weight: first.weight,
+          reason: "COLLECT: #{matching_evaluations.size} rules matched",
+          evaluator_name: @name,
+          metadata: first.metadata.merge(
+            collect_count: matching_evaluations.size,
+            collect_decisions: all_decisions,
+            collect_rule_ids: all_rule_ids
+          )
+        )
+      end
+    end
+  end
+end

data/lib/decision_agent/version.rb

@@ -3,7 +3,7 @@ module DecisionAgent
   # MAJOR: Incremented for incompatible API changes
   # MINOR: Incremented for backward-compatible functionality additions
   # PATCH: Incremented for backward-compatible bug fixes
-  VERSION = "0.2.0".freeze
+  VERSION = "0.3.0".freeze
 
   # Validate version format (semantic versioning)
   unless VERSION.match?(/\A\d+\.\d+\.\d+(-[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?(\+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*)?\z/)

data/lib/decision_agent/web/dmn_editor.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../dmn/parser"
+require_relative "../dmn/exporter"
+require_relative "../dmn/importer"
+require_relative "../dmn/validator"
+require_relative "../dmn/model"
+require_relative "../dmn/decision_tree"
+require_relative "../dmn/decision_graph"
+require_relative "../dmn/visualizer"
+
+module DecisionAgent
+  module Web
+    # DMN Editor Backend
+    # Provides API endpoints for visual DMN modeling
+    class DmnEditor
+      attr_reader :storage
+
+      def initialize(storage: nil)
+        @storage = storage || {}
+        @storage_mutex = Mutex.new
+      end
+
+      # Create a new DMN model
+      def create_model(name:, namespace: nil)
+        model_id = generate_id
+        namespace ||= "http://decisonagent.com/dmn/#{model_id}"
+
+        model = Dmn::Model.new(
+          id: model_id,
+          name: name,
+          namespace: namespace
+        )
+
+        store_model(model_id, model)
+
+        {
+          id: model_id,
+          name: name,
+          namespace: namespace,
+          decisions: [],
+          created_at: Time.now.utc.iso8601
+        }
+      end
+
+      # Get a DMN model
+      def get_model(model_id)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        serialize_model(model)
+      end
+
+      # Update DMN model metadata
+      def update_model(model_id, name: nil, namespace: nil)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        model.instance_variable_set(:@name, name) if name
+        model.instance_variable_set(:@namespace, namespace) if namespace
+
+        store_model(model_id, model)
+        serialize_model(model)
+      end
+
+      # Delete a DMN model
+      # rubocop:disable Naming/PredicateMethod
+      def delete_model(model_id)
+        @storage_mutex.synchronize do
+          @storage.delete(model_id)
+        end
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      # Add a decision to a model
+      def add_decision(model_id:, decision_id:, name:, type: "decision_table")
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = Dmn::Decision.new(
+          id: decision_id,
+          name: name
+        )
+
+        # Initialize decision logic based on type
+        case type
+        when "decision_table"
+          decision.instance_variable_set(:@decision_table, Dmn::DecisionTable.new(
+                                                             id: "#{decision_id}_table",
+                                                             hit_policy: "FIRST"
+                                                           ))
+        when "decision_tree"
+          decision.instance_variable_set(:@decision_tree, Dmn::DecisionTree.new(
+                                                            id: "#{decision_id}_tree",
+                                                            name: name
+                                                          ))
+        when "literal"
+          decision.instance_variable_set(:@literal_expression, "")
+        end
+
+        model.add_decision(decision)
+        store_model(model_id, model)
+
+        serialize_decision(decision)
+      end
+
+      # Update a decision
+      def update_decision(model_id:, decision_id:, name: nil, logic: nil)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = model.find_decision(decision_id)
+        return nil unless decision
+
+        decision.instance_variable_set(:@name, name) if name
+
+        update_decision_table(decision.decision_table, logic) if logic && decision.decision_table
+
+        store_model(model_id, model)
+        serialize_decision(decision)
+      end
+
+      # Delete a decision
+      # rubocop:disable Naming/PredicateMethod
+      def delete_decision(model_id:, decision_id:)
+        model = retrieve_model(model_id)
+        return false unless model
+
+        model.decisions.reject! { |d| d.id == decision_id }
+        store_model(model_id, model)
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      # Add input to decision table
+      def add_input(model_id:, decision_id:, input_id:, label:, type_ref: nil, expression: nil)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = model.find_decision(decision_id)
+        return nil unless decision&.decision_table
+
+        input = Dmn::Input.new(
+          id: input_id,
+          label: label,
+          type_ref: type_ref,
+          expression: expression
+        )
+
+        decision.decision_table.inputs << input
+        store_model(model_id, model)
+
+        serialize_input(input)
+      end
+
+      # Add output to decision table
+      def add_output(model_id:, decision_id:, output_id:, label:, type_ref: nil, name: nil)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = model.find_decision(decision_id)
+        return nil unless decision&.decision_table
+
+        output = Dmn::Output.new(
+          id: output_id,
+          label: label,
+          type_ref: type_ref,
+          name: name
+        )
+
+        decision.decision_table.outputs << output
+        store_model(model_id, model)
+
+        serialize_output(output)
+      end
+
+      # Add rule to decision table
+      def add_rule(model_id:, decision_id:, rule_id:, input_entries:, output_entries:, description: nil)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = model.find_decision(decision_id)
+        return nil unless decision&.decision_table
+
+        rule = Dmn::Rule.new(id: rule_id)
+        rule.instance_variable_set(:@input_entries, input_entries)
+        rule.instance_variable_set(:@output_entries, output_entries)
+        rule.instance_variable_set(:@description, description) if description
+
+        decision.decision_table.rules << rule
+        store_model(model_id, model)
+
+        serialize_rule(rule)
+      end
+
+      # Update rule
+      def update_rule(model_id:, decision_id:, rule_id:, input_entries: nil, output_entries: nil, description: nil)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = model.find_decision(decision_id)
+        return nil unless decision&.decision_table
+
+        rule = decision.decision_table.rules.find { |r| r.id == rule_id }
+        return nil unless rule
+
+        rule.instance_variable_set(:@input_entries, input_entries) if input_entries
+        rule.instance_variable_set(:@output_entries, output_entries) if output_entries
+        rule.instance_variable_set(:@description, description) if description
+
+        store_model(model_id, model)
+        serialize_rule(rule)
+      end
+
+      # Delete rule
+      # rubocop:disable Naming/PredicateMethod
+      def delete_rule(model_id:, decision_id:, rule_id:)
+        model = retrieve_model(model_id)
+        return false unless model
+
+        decision = model.find_decision(decision_id)
+        return false unless decision&.decision_table
+
+        decision.decision_table.rules.reject! { |r| r.id == rule_id }
+        store_model(model_id, model)
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      # Validate a DMN model
+      def validate_model(model_id)
+        model = retrieve_model(model_id)
+        return { valid: false, errors: ["Model not found"] } unless model
+
+        validator = Dmn::Validator.new
+        validator.validate(model)
+
+        {
+          valid: validator.valid?,
+          errors: validator.errors,
+          warnings: validator.warnings
+        }
+      end
+
+      # Export DMN model to XML
+      def export_to_xml(model_id)
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        exporter = Dmn::Exporter.new
+        exporter.export(model)
+      end
+
+      # Import DMN model from XML
+      def import_from_xml(xml_content, name: nil)
+        parser = Dmn::Parser.new
+        model = parser.parse(xml_content)
+
+        # Generate new ID for imported model
+        model_id = generate_id
+        model.instance_variable_set(:@id, model_id)
+        model.instance_variable_set(:@name, name) if name
+
+        store_model(model_id, model)
+
+        serialize_model(model)
+      end
+
+      # Generate visualization for decision tree
+      def visualize_tree(model_id:, decision_id:, format: "svg")
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        decision = model.find_decision(decision_id)
+        return nil unless decision || !decision.decision_tree
+
+        case format.to_s.downcase
+        when "svg"
+          Dmn::Visualizer.tree_to_svg(decision.decision_tree)
+        when "dot"
+          Dmn::Visualizer.tree_to_dot(decision.decision_tree)
+        when "mermaid"
+          Dmn::Visualizer.tree_to_mermaid(decision.decision_tree)
+        end
+      end
+
+      # Generate visualization for decision graph
+      def visualize_graph(model_id:, format: "svg")
+        model = retrieve_model(model_id)
+        return nil unless model
+
+        # Convert model to decision graph
+        graph = Dmn::DecisionGraph.new(id: model.id, name: model.name)
+        model.decisions.each do |decision|
+          node = Dmn::DecisionNode.new(
+            id: decision.id,
+            name: decision.name,
+            decision_logic: decision.decision_table || decision.decision_tree
+          )
+
+          # Add dependencies from information requirements
+          decision.information_requirements.each do |req|
+            node.add_dependency(req[:decision_id], req[:variable_name])
+          end
+
+          graph.add_decision(node)
+        end
+
+        case format.to_s.downcase
+        when "svg"
+          Dmn::Visualizer.graph_to_svg(graph)
+        when "dot"
+          Dmn::Visualizer.graph_to_dot(graph)
+        when "mermaid"
+          Dmn::Visualizer.graph_to_mermaid(graph)
+        end
+      end
+
+      # List all models
+      def list_models
+        @storage_mutex.synchronize do
+          @storage.map do |id, model|
+            {
+              id: id,
+              name: model.name,
+              namespace: model.namespace,
+              decision_count: model.decisions.size
+            }
+          end
+        end
+      end
+
+      private
+
+      def generate_id
+        "dmn_#{Time.now.to_i}_#{rand(10_000)}"
+      end
+
+      def store_model(model_id, model)
+        @storage_mutex.synchronize do
+          @storage[model_id] = model
+        end
+      end
+
+      def retrieve_model(model_id)
+        @storage_mutex.synchronize do
+          @storage[model_id]
+        end
+      end
+
+      def update_decision_table(table, logic)
+        table.instance_variable_set(:@hit_policy, logic[:hit_policy]) if logic[:hit_policy]
+        table.instance_variable_set(:@inputs, logic[:inputs]) if logic[:inputs]
+        table.instance_variable_set(:@outputs, logic[:outputs]) if logic[:outputs]
+        table.instance_variable_set(:@rules, logic[:rules]) if logic[:rules]
+      end
+
+      def serialize_model(model)
+        {
+          id: model.id,
+          name: model.name,
+          namespace: model.namespace,
+          decisions: model.decisions.map { |d| serialize_decision(d) }
+        }
+      end
+
+      def serialize_decision(decision)
+        result = {
+          id: decision.id,
+          name: decision.name
+        }
+
+        if decision.decision_table
+          result[:decision_table] = serialize_decision_table(decision.decision_table)
+        elsif decision.decision_tree
+          result[:decision_tree] = decision.decision_tree.to_h
+        elsif decision.instance_variable_get(:@literal_expression)
+          result[:literal_expression] = decision.instance_variable_get(:@literal_expression)
+        end
+
+        result[:information_requirements] = decision.information_requirements if decision.information_requirements.any?
+
+        result
+      end
+
+      def serialize_decision_table(table)
+        {
+          id: table.id,
+          hit_policy: table.hit_policy,
+          inputs: table.inputs.map { |i| serialize_input(i) },
+          outputs: table.outputs.map { |o| serialize_output(o) },
+          rules: table.rules.map { |r| serialize_rule(r) }
+        }
+      end
+
+      def serialize_input(input)
+        {
+          id: input.id,
+          label: input.label,
+          type_ref: input.type_ref,
+          expression: input.expression
+        }
+      end
+
+      def serialize_output(output)
+        {
+          id: output.id,
+          label: output.label,
+          type_ref: output.type_ref,
+          name: output.name
+        }
+      end
+
+      def serialize_rule(rule)
+        {
+          id: rule.id,
+          input_entries: rule.input_entries,
+          output_entries: rule.output_entries,
+          description: rule.description
+        }
+      end
+    end
+  end
+end