decision_agent 0.3.0 → 1.1.0

data/lib/decision_agent/simulation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Simulation and What-If Analysis module
+# Provides tools for scenario testing, historical replay, impact analysis, shadow testing, and Monte Carlo simulation
+
+require_relative "simulation/errors"
+require_relative "simulation/replay_engine"
+require_relative "simulation/what_if_analyzer"
+require_relative "simulation/impact_analyzer"
+require_relative "simulation/shadow_test_engine"
+require_relative "simulation/scenario_engine"
+require_relative "simulation/scenario_library"
+require_relative "simulation/monte_carlo_simulator"
+
+module DecisionAgent
+  module Simulation
+    # Main entry point for simulation features
+  end
+end

data/lib/decision_agent/testing/batch_test_importer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "csv"
 require "roo"
 
@@ -44,8 +46,9 @@ module DecisionAgent
         if options[:progress_callback]
           begin
             total_rows = count_csv_rows(file_path, options[:skip_header])
-          rescue StandardError
+          rescue StandardError => e
             # If counting fails, continue without progress tracking
+            warn "[DecisionAgent] Failed to count CSV rows: #{e.message}"
             total_rows = nil
           end
         end
@@ -364,8 +367,9 @@ module DecisionAgent
           count += 1
         end
         count
-      rescue StandardError
+      rescue StandardError => e
         # If we can't count, return nil (progress tracking will be disabled)
+        warn "[DecisionAgent] Failed to count CSV rows for '#{file_path}': #{e.message}"
         nil
       end
     end

data/lib/decision_agent/testing/batch_test_runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module DecisionAgent
@@ -153,7 +155,7 @@ module DecisionAgent
             loop do
               scenario = begin
                 queue.pop(true)
-              rescue StandardError
+              rescue ThreadError
                 nil
               end
               break unless scenario
@@ -228,7 +230,8 @@ module DecisionAgent
         data
       rescue JSON::ParserError
         { completed_scenario_ids: [], last_updated: nil }
-      rescue StandardError
+      rescue StandardError => e
+        warn "[DecisionAgent] Failed to load checkpoint file: #{e.message}"
         { completed_scenario_ids: [], last_updated: nil }
       end
 

data/lib/decision_agent/testing/test_coverage_analyzer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 
 module DecisionAgent

data/lib/decision_agent/testing/test_result_comparator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DecisionAgent
   module Testing
     # Comparison result for a single test scenario

data/lib/decision_agent/testing/test_scenario.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DecisionAgent
   module Testing
     # Represents a single test scenario with context and expected results

data/lib/decision_agent/version.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module DecisionAgent
   # Semantic version: MAJOR.MINOR.PATCH
   # MAJOR: Incremented for incompatible API changes
   # MINOR: Incremented for backward-compatible functionality additions
   # PATCH: Incremented for backward-compatible bug fixes
-  VERSION = "0.3.0".freeze
+  VERSION = "1.1.0"
 
   # 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/versioning/activerecord_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "adapter"
 require_relative "file_storage_adapter"
 
@@ -16,40 +18,43 @@ module DecisionAgent
       end
 
       def create_version(rule_id:, content:, metadata: {})
-        # Use a transaction with pessimistic locking to prevent race conditions
-        version = nil
-
         # Validate status if provided
         status = metadata[:status] || "active"
         validate_status!(status)
 
-        rule_version_class.transaction do
-          # Lock the last version for this rule to prevent concurrent reads
-          # This ensures only one thread can calculate the next version number at a time
-          last_version = rule_version_class.where(rule_id: rule_id)
-                                           .order(version_number: :desc)
-                                           .lock
-                                           .first
-          next_version_number = last_version ? last_version.version_number + 1 : 1
-
-          # Deactivate previous active versions
-          # Use update! instead of update_all to trigger validations
-          rule_version_class.where(rule_id: rule_id, status: "active").find_each do |v|
-            v.update!(status: "archived")
+        # Retry on SQLite busy exceptions (common with concurrent operations)
+        retry_with_backoff(max_retries: 10) do
+          # Use a transaction with pessimistic locking to prevent race conditions
+          version = nil
+
+          rule_version_class.transaction do
+            # Lock the last version for this rule to prevent concurrent reads
+            # This ensures only one thread can calculate the next version number at a time
+            last_version = rule_version_class.where(rule_id: rule_id)
+                                             .order(version_number: :desc)
+                                             .lock
+                                             .first
+            next_version_number = last_version ? last_version.version_number + 1 : 1
+
+            # Deactivate previous active versions
+            # Use update_all for better concurrency (avoids SQLite locking issues)
+            # Status "archived" is valid, so no need to trigger validations
+            rule_version_class.where(rule_id: rule_id, status: "active")
+                              .update_all(status: "archived")
+
+            # Create new version
+            version = rule_version_class.create!(
+              rule_id: rule_id,
+              version_number: next_version_number,
+              content: content.to_json,
+              created_by: metadata[:created_by] || "system",
+              changelog: metadata[:changelog] || "Version #{next_version_number}",
+              status: status
+            )
           end
 
-          # Create new version
-          version = rule_version_class.create!(
-            rule_id: rule_id,
-            version_number: next_version_number,
-            content: content.to_json,
-            created_by: metadata[:created_by] || "system",
-            changelog: metadata[:changelog] || "Version #{next_version_number}",
-            status: status
-          )
+          serialize_version(version)
         end
-
-        serialize_version(version)
       end
 
       def list_versions(rule_id:, limit: nil)
@@ -60,6 +65,13 @@ module DecisionAgent
         query.map { |v| serialize_version(v) }
       end
 
+      def list_all_versions(limit: nil)
+        query = rule_version_class.order(created_at: :desc)
+        query = query.limit(limit) if limit
+
+        query.map { |v| serialize_version(v) }
+      end
+
       def get_version(version_id:)
         version = rule_version_class.find_by(id: version_id)
         version ? serialize_version(version) : nil
@@ -79,26 +91,44 @@ module DecisionAgent
       end
 
       def activate_version(version_id:)
-        version = nil
-
-        rule_version_class.transaction do
-          # Find and lock the version to activate
-          version = rule_version_class.lock.find(version_id)
-
-          # Deactivate all other versions for this rule within the same transaction
-          # The lock ensures only one thread can perform this operation at a time
-          # Use update! instead of update_all to trigger validations
-          rule_version_class.where(rule_id: version.rule_id, status: "active")
-                            .where.not(id: version_id)
-                            .find_each do |v|
-                              v.update!(status: "archived")
+        # Retry on SQLite busy exceptions (common with concurrent operations)
+        retry_with_backoff(max_retries: 10) do
+          version = nil
+
+          rule_version_class.transaction do
+            # Find and lock the version to activate
+            version = rule_version_class.lock.find(version_id)
+
+            # Deactivate all other versions for this rule within the same transaction
+            # The lock ensures only one thread can perform this operation at a time
+            # Use update_all for better concurrency (avoids SQLite locking issues)
+            # Status "archived" is valid, so no need to trigger validations
+            rule_version_class.where(rule_id: version.rule_id, status: "active")
+                              .where.not(id: version_id)
+                              .update_all(status: "archived")
+
+            # Activate this version
+            version.update!(status: "active")
           end
 
-          # Activate this version
-          version.update!(status: "active")
+          serialize_version(version)
         end
+      end
+
+      def delete_version(version_id:)
+        version = rule_version_class.find_by(id: version_id)
+
+        # Version not found
+        raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless version
 
-        serialize_version(version)
+        # Prevent deletion of active versions
+        raise DecisionAgent::ValidationError, "Cannot delete active version. Please activate another version first." if version.status == "active"
+
+        # Delete the version
+        version.destroy
+        true
+      rescue ActiveRecord::RecordNotFound
+        raise DecisionAgent::NotFoundError, "Version not found: #{version_id}"
       end
 
       private
@@ -113,6 +143,41 @@ module DecisionAgent
         end
       end
 
+      # Retry database operations that may encounter SQLite busy exceptions
+      # This is especially important for concurrent operations on different rules
+      def retry_with_backoff(max_retries: 10, base_delay: 0.01)
+        retries = 0
+        begin
+          yield
+        rescue ActiveRecord::StatementInvalid => e
+          # Check if it's a SQLite busy exception
+          # Handle different SQLite adapter implementations
+          is_busy = begin
+            # Check the underlying exception type
+            cause = e.cause
+            if cause
+              cause.class.name.include?("BusyException") ||
+                cause.class.name.include?("SQLite3::BusyException")
+            else
+              false
+            end
+          rescue StandardError => cause_check_error
+            warn "[DecisionAgent] Error checking busy exception cause: #{cause_check_error.message}"
+            false
+          end || e.message.include?("database is locked") ||
+                    e.message.include?("SQLite3::BusyException") ||
+                    e.message.include?("BusyException")
+
+          raise unless is_busy && retries < max_retries
+
+          retries += 1
+          # Exponential backoff with jitter
+          delay = (base_delay * (2**retries)) + (rand * base_delay)
+          sleep(delay)
+          retry
+        end
+      end
+
       def serialize_version(version)
         # Parse JSON content with proper error handling
         parsed_content = begin

data/lib/decision_agent/versioning/adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DecisionAgent
   module Versioning
     # Abstract base class for version storage adapters
@@ -20,6 +22,13 @@ module DecisionAgent
         raise NotImplementedError, "#{self.class} must implement #list_versions"
       end
 
+      # List all versions across all rules
+      # @param limit [Integer, nil] Optional limit for number of versions
+      # @return [Array<Hash>] Array of version hashes
+      def list_all_versions(limit: nil)
+        raise NotImplementedError, "#{self.class} must implement #list_all_versions"
+      end
+
       # Get a specific version by ID
       # @param version_id [String, Integer] The version identifier
       # @return [Hash, nil] The version hash or nil if not found

data/lib/decision_agent/versioning/file_storage_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "adapter"
 require "json"
 require "fileutils"
@@ -86,12 +88,20 @@ module DecisionAgent
         end
       end
 
+      def list_all_versions(limit: nil)
+        @version_index_lock.synchronize do
+          versions = all_versions_unsafe
+          limit ? versions.take(limit) : versions
+        end
+      end
+
       def get_version(version_id:)
         # Use index to find rule_id quickly - O(1) instead of O(n)
         begin
           rule_id = get_rule_id_from_index(version_id)
-        rescue StandardError
+        rescue StandardError => e
           # If index lookup fails, version doesn't exist
+          warn "[DecisionAgent] Version index lookup failed for '#{version_id}': #{e.message}"
           return nil
         end
         return nil unless rule_id
@@ -103,8 +113,9 @@ module DecisionAgent
             versions = list_versions_unsafe(rule_id: rule_id)
             versions.find { |v| v[:id] == version_id }
           end
-        rescue StandardError
+        rescue StandardError => e
           # If any error occurs during lookup, treat as version not found
+          warn "[DecisionAgent] Version lookup failed for '#{version_id}': #{e.message}"
           nil
         end
       end
@@ -152,8 +163,9 @@ module DecisionAgent
         # Use index to find rule_id quickly - O(1) instead of O(n)
         begin
           rule_id = get_rule_id_from_index(version_id)
-        rescue StandardError
+        rescue StandardError => e
           # If index lookup fails, version doesn't exist
+          warn "[DecisionAgent] Version index lookup failed for '#{version_id}': #{e.message}"
           raise DecisionAgent::NotFoundError, "Version not found: #{version_id}"
         end
 
@@ -218,15 +230,16 @@ module DecisionAgent
         rescue DecisionAgent::ValidationError, DecisionAgent::NotFoundError
           # Re-raise expected errors
           raise
-        rescue StandardError
+        rescue StandardError => e
           # If any unexpected error occurs during the lock operation, treat as version not found
           # This prevents 500 errors from propagating when version doesn't exist or is in an invalid state
           # This handles ThreadError (deadlocks, recursive locks), SystemCallError (file system issues), etc.
           # This is safe because if the version existed and was valid, we would have found it above
+          warn "[DecisionAgent] Version delete lock operation failed for '#{version_id}': #{e.message}"
           begin
             remove_from_index(version_id)
-          rescue StandardError
-            nil
+          rescue StandardError => cleanup_error
+            warn "[DecisionAgent] Failed to clean up index for '#{version_id}': #{cleanup_error.message}"
           end
           raise DecisionAgent::NotFoundError, "Version not found: #{version_id}"
         end

data/lib/decision_agent/versioning/version_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DecisionAgent
   module Versioning
     # High-level service for managing rule versions
@@ -40,6 +42,13 @@ module DecisionAgent
         @adapter.list_versions(rule_id: rule_id, limit: limit)
       end
 
+      # Get all versions across all rules
+      # @param limit [Integer, nil] Optional limit
+      # @return [Array<Hash>] Array of versions
+      def list_all_versions(limit: nil)
+        @adapter.list_all_versions(limit: limit)
+      end
+
       # Get a specific version
       # @param version_id [String, Integer] The version identifier
       # @return [Hash, nil] The version or nil

data/lib/decision_agent/web/dmn_editor/serialization.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Web
+    class DmnEditor
+      module Serialization
+        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
+end

data/lib/decision_agent/web/dmn_editor/xml_builder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Web
+    class DmnEditor
+      module XmlBuilder
+        def generate_dmn_xml(model)
+          require "nokogiri"
+
+          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+            xml.definitions(
+              "xmlns" => "https://www.omg.org/spec/DMN/20191111/MODEL/",
+              "xmlns:dmndi" => "https://www.omg.org/spec/DMN/20191111/DMNDI/",
+              "xmlns:dc" => "http://www.omg.org/spec/DMN/20180521/DC/",
+              "id" => "definitions_#{model.id}",
+              "name" => model.name,
+              "namespace" => model.namespace || "http://decision_agent.local"
+            ) do
+              model.decisions.each do |decision|
+                xml.decision(id: decision.id, name: decision.name) do
+                  if decision.decision_table
+                    build_decision_table_xml(xml, decision.decision_table)
+                  elsif decision.decision_tree
+                    xml.comment "Decision Tree (not fully supported in DMN XML export yet)"
+                  elsif decision.instance_variable_get(:@literal_expression)
+                    xml.literalExpression do
+                      xml.text decision.instance_variable_get(:@literal_expression)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          builder.to_xml
+        end
+
+        def build_decision_table_xml(xml, table)
+          xml.decisionTable(
+            id: table.id,
+            hitPolicy: table.hit_policy || "FIRST",
+            outputLabel: "output"
+          ) do
+            build_inputs_xml(xml, table)
+            build_outputs_xml(xml, table)
+            build_rules_xml(xml, table)
+          end
+        end
+
+        private
+
+        def build_inputs_xml(xml, table)
+          table.inputs.each do |input|
+            xml.input(id: input.id, label: input.label) do
+              xml.inputExpression(typeRef: input.type_ref || "string") do
+                text_node = Nokogiri::XML::Node.new("text", xml.doc)
+                text_node.content = input.expression || input.label
+                xml.parent.add_child(text_node)
+              end
+            end
+          end
+        end
+
+        def build_outputs_xml(xml, table)
+          table.outputs.each do |output|
+            xml.output(
+              id: output.id,
+              label: output.label,
+              name: output.name || output.label,
+              typeRef: output.type_ref || "string"
+            )
+          end
+        end
+
+        def build_rules_xml(xml, table)
+          table.rules.each { |rule| build_rule_xml(xml, rule) }
+        end
+
+        def build_rule_xml(xml, rule)
+          xml.rule(id: rule.id) do
+            rule.input_entries.each_with_index do |entry, idx|
+              add_entry_element(xml, "inputEntry", "#{rule.id}_input_#{idx + 1}", entry)
+            end
+            rule.output_entries.each_with_index do |entry, idx|
+              add_entry_element(xml, "outputEntry", "#{rule.id}_output_#{idx + 1}", entry)
+            end
+            add_rule_description(xml, rule)
+          end
+        end
+
+        def add_entry_element(xml, tag, id, content)
+          xml.send(tag, id: id) do
+            text_node = Nokogiri::XML::Node.new("text", xml.doc)
+            text_node.content = content.to_s
+            xml.parent.add_child(text_node)
+          end
+        end
+
+        def add_rule_description(xml, rule)
+          return if rule.description.nil? || rule.description.empty?
+
+          xml.description { xml.text rule.description }
+        end
+      end
+    end
+  end
+end