decision_agent 1.1.0 → 1.2.0

data/lib/decision_agent/simulation/impact_analyzer.rb

@@ -5,7 +5,6 @@ require_relative "errors"
 module DecisionAgent
   module Simulation
     # Analyzer for quantifying rule change impact
-    # rubocop:disable Metrics/ClassLength
     class ImpactAnalyzer
       attr_reader :version_manager
 
@@ -494,7 +493,6 @@ module DecisionAgent
           "#{parts.join('. ')}."
         end
       end
-      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/decision_agent/simulation/monte_carlo_simulator.rb

@@ -27,7 +27,6 @@ module DecisionAgent
     #
     #   puts "Decision probabilities: #{results[:decision_probabilities]}"
     #   puts "Average confidence: #{results[:average_confidence]}"
-    # rubocop:disable Metrics/ClassLength
     class MonteCarloSimulator
       attr_reader :agent, :version_manager
 
@@ -632,7 +631,6 @@ module DecisionAgent
         end
         target[last_key.to_sym] = value
       end
-      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/decision_agent/simulation/replay_engine.rb

@@ -14,7 +14,6 @@ end
 module DecisionAgent
   module Simulation
     # Engine for replaying historical decisions and backtesting rule changes
-    # rubocop:disable Metrics/ClassLength
     class ReplayEngine
       attr_reader :agent, :version_manager
 
@@ -482,7 +481,6 @@ module DecisionAgent
           errors: results.count { |r| r[:error] }
         }
       end
-      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/decision_agent/simulation/what_if_analyzer.rb

@@ -5,7 +5,6 @@ require_relative "errors"
 module DecisionAgent
   module Simulation
     # Analyzer for what-if scenario simulation
-    # rubocop:disable Metrics/ClassLength
     class WhatIfAnalyzer
       attr_reader :agent, :version_manager
 
@@ -1002,7 +1001,6 @@ module DecisionAgent
           "<div class='legend-item'><div class='legend-color' style='background: #{color};'></div><span>#{decision}</span></div>"
         end.join
       end
-      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/decision_agent/testing/batch_test_importer.rb

@@ -24,7 +24,6 @@ module DecisionAgent
       #   - :skip_header [Boolean] Skip first row (default: true)
       #   - :progress_callback [Proc] Callback for progress updates (called with { processed: N, total: M, percentage: X })
       # @return [Array<TestScenario>] Array of test scenarios
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def import_csv(file_path, options = {})
         @errors = []
         @warnings = []
@@ -101,7 +100,6 @@ module DecisionAgent
 
         scenarios
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       # Import test scenarios from an Excel file (.xlsx, .xls)
       # @param file_path [String] Path to Excel file
@@ -109,7 +107,6 @@ module DecisionAgent
       #   - :sheet [String|Integer] Sheet name or index (default: first sheet)
       #   - :progress_callback [Proc] Callback for progress updates
       # @return [Array<TestScenario>] Array of test scenarios
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def import_excel(file_path, options = {})
         @errors = []
         @warnings = []
@@ -223,7 +220,6 @@ module DecisionAgent
           raise ImportError, "Failed to read Excel file: #{e.message}"
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       # Import test scenarios from an array of hashes (for programmatic use)
       # @param data [Array<Hash>] Array of hashes with test data

data/lib/decision_agent/testing/batch_test_runner.rb

@@ -55,7 +55,6 @@ module DecisionAgent
       #   - :feedback [Hash] Optional feedback to pass to agent
       #   - :checkpoint_file [String] Path to checkpoint file for resume capability (optional)
       # @return [Array<TestResult>] Array of test results
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def run(scenarios, options = {})
         @results = []
         @checkpoint_file = options[:checkpoint_file]
@@ -141,7 +140,6 @@ module DecisionAgent
           total_execution_time_ms: execution_times.sum
         }
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       private
 

data/lib/decision_agent/testing/test_result_comparator.rb

@@ -6,7 +6,6 @@ module DecisionAgent
     class ComparisonResult
       attr_reader :scenario_id, :match, :decision_match, :confidence_match, :differences, :actual, :expected
 
-      # rubocop:disable Metrics/ParameterLists
       def initialize(scenario_id:, match:, decision_match:, confidence_match:, differences:, actual:, expected:)
         @scenario_id = scenario_id.to_s.freeze
         @match = match
@@ -18,7 +17,6 @@ module DecisionAgent
 
         freeze
       end
-      # rubocop:enable Metrics/ParameterLists
 
       def to_h
         {
@@ -140,78 +138,71 @@ module DecisionAgent
 
       private
 
-      # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
       def compare_single(scenario, result)
+        return failed_comparison_result(scenario, result) if result.nil? || !result.success?
+
         differences = []
-        confidence_match = false
-
-        if result.nil? || !result.success?
-          differences << "Test execution failed: #{result&.error&.message || 'No result'}"
-          return ComparisonResult.new(
-            scenario_id: scenario.id,
-            match: false,
-            decision_match: false,
-            confidence_match: false,
-            differences: differences,
-            actual: { decision: nil, confidence: nil },
-            expected: {
-              decision: scenario.expected_decision,
-              confidence: scenario.expected_confidence
-            }
-          )
-        end
+        decision_match = compare_decision(scenario, result, differences)
+        confidence_match = compare_confidence(scenario, result, differences)
+
+        ComparisonResult.new(
+          scenario_id: scenario.id,
+          match: decision_match && confidence_match,
+          decision_match: decision_match,
+          confidence_match: confidence_match,
+          differences: differences,
+          actual: { decision: result.decision&.to_s, confidence: result.confidence },
+          expected: { decision: scenario.expected_decision&.to_s, confidence: scenario.expected_confidence }
+        )
+      end
+
+      def failed_comparison_result(scenario, result)
+        ComparisonResult.new(
+          scenario_id: scenario.id,
+          match: false,
+          decision_match: false,
+          confidence_match: false,
+          differences: ["Test execution failed: #{result&.error&.message || 'No result'}"],
+          actual: { decision: nil, confidence: nil },
+          expected: { decision: scenario.expected_decision, confidence: scenario.expected_confidence }
+        )
+      end
 
-        # Compare decision
-        expected_decision = scenario.expected_decision&.to_s
-        actual_decision = result.decision&.to_s
+      def compare_decision(scenario, result, differences)
+        expected = scenario.expected_decision&.to_s
+        actual = result.decision&.to_s
 
-        decision_match = if expected_decision.nil?
-                           true # No expectation, so it matches
-                         elsif @options[:fuzzy_match]
-                           fuzzy_decision_match?(expected_decision, actual_decision)
-                         else
-                           expected_decision == actual_decision
-                         end
+        match = if expected.nil?
+                  true
+                elsif @options[:fuzzy_match]
+                  fuzzy_decision_match?(expected, actual)
+                else
+                  expected == actual
+                end
 
-        differences << "Decision mismatch: expected '#{expected_decision}', got '#{actual_decision}'" unless decision_match
+        differences << "Decision mismatch: expected '#{expected}', got '#{actual}'" unless match
+        match
+      end
+
+      def compare_confidence(scenario, result, differences)
+        expected = scenario.expected_confidence
+        actual = result.confidence
 
-        # Compare confidence
-        expected_confidence = scenario.expected_confidence
-        actual_confidence = result.confidence
+        return true if expected.nil?
 
-        if expected_confidence.nil?
-          confidence_match = true # No expectation, so it matches
-        elsif actual_confidence.nil?
-          confidence_match = false
+        if actual.nil?
           differences << "Confidence missing in actual result"
-        else
-          tolerance = @options[:confidence_tolerance]
-          confidence_match = (expected_confidence - actual_confidence).abs <= tolerance
-          unless confidence_match
-            diff = (expected_confidence - actual_confidence).abs.round(4)
-            differences << "Confidence mismatch: expected #{expected_confidence}, got #{actual_confidence} (diff: #{diff})"
-          end
+          return false
         end
 
-        match = decision_match && confidence_match
-
-        ComparisonResult.new(
-          scenario_id: scenario.id,
-          match: match,
-          decision_match: decision_match,
-          confidence_match: confidence_match,
-          differences: differences,
-          actual: {
-            decision: actual_decision,
-            confidence: actual_confidence
-          },
-          expected: {
-            decision: expected_decision,
-            confidence: expected_confidence
-          }
-        )
+        tolerance = @options[:confidence_tolerance]
+        match = (expected - actual).abs <= tolerance
+        unless match
+          diff = (expected - actual).abs.round(4)
+          differences << "Confidence mismatch: expected #{expected}, got #{actual} (diff: #{diff})"
+        end
+        match
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
       def fuzzy_decision_match?(expected, actual)
         return true if expected == actual

data/lib/decision_agent/version.rb

@@ -5,7 +5,7 @@ module DecisionAgent
   # MAJOR: Incremented for incompatible API changes
   # MINOR: Incremented for backward-compatible functionality additions
   # PATCH: Incremented for backward-compatible bug fixes
-  VERSION = "1.1.0"
+  VERSION = "1.2.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

@@ -131,6 +131,47 @@ module DecisionAgent
         raise DecisionAgent::NotFoundError, "Version not found: #{version_id}"
       end
 
+      # Create (or update) a named tag pointing to a specific version.
+      # Tags are unique per model; calling this with an existing name re-points the tag.
+      def create_tag(model_id:, version_id:, name:)
+        raise DecisionAgent::ValidationError, "Tag name cannot be blank" if name.nil? || name.to_s.strip.empty?
+        raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless get_version(version_id: version_id)
+
+        retry_with_backoff(max_retries: 10) do
+          tag = nil
+          rule_version_tag_class.transaction do
+            existing = rule_version_tag_class.find_by(model_id: model_id, name: name)
+            if existing
+              existing.update!(version_id: version_id)
+              tag = existing.reload
+            else
+              tag = rule_version_tag_class.create!(model_id: model_id, name: name, version_id: version_id)
+            end
+          end
+          serialize_tag(tag)
+        end
+      end
+
+      # Retrieve a tag by name for a given model.
+      def get_tag(model_id:, name:)
+        tag = rule_version_tag_class.find_by(model_id: model_id, name: name)
+        tag ? serialize_tag(tag) : nil
+      end
+
+      # List all tags for a given model, sorted by name.
+      def list_tags(model_id:)
+        rule_version_tag_class.where(model_id: model_id).order(name: :asc).map { |t| serialize_tag(t) }
+      end
+
+      # Delete a tag by name. Returns true if deleted, false if the tag did not exist.
+      def delete_tag(model_id:, name:)
+        tag = rule_version_tag_class.find_by(model_id: model_id, name: name)
+        return false unless tag
+
+        tag.destroy
+        true
+      end
+
       private
 
       def rule_version_class
@@ -143,6 +184,15 @@ module DecisionAgent
         end
       end
 
+      def rule_version_tag_class
+        if defined?(::RuleVersionTag)
+          ::RuleVersionTag
+        else
+          raise DecisionAgent::ConfigurationError,
+                "RuleVersionTag model not found. Please run the versioning generator to create it."
+        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)
@@ -157,7 +207,9 @@ module DecisionAgent
             cause = e.cause
             if cause
               cause.class.name.include?("BusyException") ||
-                cause.class.name.include?("SQLite3::BusyException")
+                cause.class.name.include?("SQLite3::BusyException") ||
+                cause.class.name.include?("LockedException") ||
+                cause.class.name.include?("SQLite3::LockedException")
             else
               false
             end
@@ -165,8 +217,10 @@ module DecisionAgent
             warn "[DecisionAgent] Error checking busy exception cause: #{cause_check_error.message}"
             false
           end || e.message.include?("database is locked") ||
+                    e.message.include?("database table is locked") ||
                     e.message.include?("SQLite3::BusyException") ||
-                    e.message.include?("BusyException")
+                    e.message.include?("BusyException") ||
+                    e.message.include?("LockedException")
 
           raise unless is_busy && retries < max_retries
 
@@ -201,6 +255,14 @@ module DecisionAgent
           status: version.status
         }
       end
+
+      def serialize_tag(tag)
+        {
+          name: tag.name,
+          version_id: tag.version_id,
+          created_at: tag.updated_at || tag.created_at
+        }
+      end
     end
   end
 end

data/lib/decision_agent/versioning/adapter.rb

@@ -82,6 +82,39 @@ module DecisionAgent
         raise NotImplementedError, "#{self.class} must implement #delete_version"
       end
 
+      # Create (or update) a named tag pointing to a specific version.
+      # Tags are unique per model; calling this with an existing name re-points the tag.
+      # @param model_id [String] The rule/model identifier
+      # @param version_id [String] The version to tag
+      # @param name [String] The tag name (e.g. "release-candidate")
+      # @return [Hash] The created/updated tag ({ name:, version_id:, created_at: })
+      def create_tag(model_id:, version_id:, name:)
+        raise NotImplementedError, "#{self.class} must implement #create_tag"
+      end
+
+      # Retrieve a tag by name for a given model.
+      # @param model_id [String] The rule/model identifier
+      # @param name [String] The tag name
+      # @return [Hash, nil] The tag hash or nil if not found
+      def get_tag(model_id:, name:)
+        raise NotImplementedError, "#{self.class} must implement #get_tag"
+      end
+
+      # List all tags for a given model.
+      # @param model_id [String] The rule/model identifier
+      # @return [Array<Hash>] Array of tag hashes, sorted by name
+      def list_tags(model_id:)
+        raise NotImplementedError, "#{self.class} must implement #list_tags"
+      end
+
+      # Delete a tag by name.
+      # @param model_id [String] The rule/model identifier
+      # @param name [String] The tag name
+      # @return [Boolean] True if deleted, false if tag did not exist
+      def delete_tag(model_id:, name:)
+        raise NotImplementedError, "#{self.class} must implement #delete_tag"
+      end
+
       private
 
       # Calculate differences between two content hashes

data/lib/decision_agent/versioning/file_storage_adapter.rb

@@ -159,6 +159,45 @@ module DecisionAgent
         end
       end
 
+      def create_tag(model_id:, version_id:, name:)
+        raise DecisionAgent::ValidationError, "Tag name cannot be blank" if name.nil? || name.to_s.strip.empty?
+
+        # Validate the version exists
+        version = get_version(version_id: version_id)
+        raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless version
+
+        with_rule_lock(model_id) do
+          tags = read_tags_unsafe(model_id)
+          tag = { name: name, version_id: version_id, created_at: Time.now.utc.iso8601 }
+          tags[name] = tag
+          write_tags_unsafe(model_id, tags)
+          tag
+        end
+      end
+
+      def get_tag(model_id:, name:)
+        with_rule_lock(model_id) do
+          read_tags_unsafe(model_id)[name]
+        end
+      end
+
+      def list_tags(model_id:)
+        with_rule_lock(model_id) do
+          read_tags_unsafe(model_id).values.sort_by { |t| t[:name] }
+        end
+      end
+
+      def delete_tag(model_id:, name:)
+        with_rule_lock(model_id) do
+          tags = read_tags_unsafe(model_id)
+          return false unless tags.key?(name)
+
+          tags.delete(name)
+          write_tags_unsafe(model_id, tags)
+          true
+        end
+      end
+
       def delete_version(version_id:)
         # Use index to find rule_id quickly - O(1) instead of O(n)
         begin
@@ -253,11 +292,13 @@ module DecisionAgent
 
         return versions unless Dir.exist?(rule_dir)
 
-        Dir.glob(File.join(rule_dir, "*.json")).each do |file|
-          versions << JSON.parse(File.read(file), symbolize_names: true)
-        rescue JSON::ParserError, Errno::ENOENT
-          # Skip corrupted or deleted files
-          next
+        Dir.glob(File.join(rule_dir, "*.json"))
+           .reject { |f| File.basename(f).start_with?("_") }
+           .each do |file|
+             versions << JSON.parse(File.read(file), symbolize_names: true)
+           rescue JSON::ParserError, Errno::ENOENT
+             # Skip corrupted or deleted files
+             next
         end
 
         versions.sort_by! { |v| -v[:version_number] }
@@ -268,8 +309,10 @@ module DecisionAgent
         versions = []
         return versions unless Dir.exist?(@storage_path)
 
-        Dir.glob(File.join(@storage_path, "*", "*.json")).each do |file|
-          versions << JSON.parse(File.read(file), symbolize_names: true)
+        Dir.glob(File.join(@storage_path, "*", "*.json"))
+           .reject { |f| File.basename(f).start_with?("_") }
+           .each do |file|
+             versions << JSON.parse(File.read(file), symbolize_names: true)
         end
 
         versions
@@ -366,6 +409,33 @@ module DecisionAgent
           @version_index.delete(version_id)
         end
       end
+
+      # Tags helpers — called while the rule lock is already held (unsafe = no extra lock)
+
+      def tags_filepath(model_id)
+        rule_dir = File.join(@storage_path, sanitize_filename(model_id))
+        FileUtils.mkdir_p(rule_dir)
+        File.join(rule_dir, "_tags.json")
+      end
+
+      def read_tags_unsafe(model_id)
+        path = tags_filepath(model_id)
+        return {} unless File.exist?(path)
+
+        JSON.parse(File.read(path), symbolize_names: false)
+            .transform_values { |t| t.transform_keys(&:to_sym) }
+      rescue JSON::ParserError
+        {}
+      end
+
+      def write_tags_unsafe(model_id, tags)
+        path = tags_filepath(model_id)
+        temp = "#{path}.tmp.#{Process.pid}.#{Thread.current.object_id}"
+        File.write(temp, JSON.pretty_generate(tags))
+        File.rename(temp, path)
+      ensure
+        FileUtils.rm_f(temp)
+      end
     end
   end
 end

data/lib/decision_agent/versioning/version_manager.rb

@@ -18,8 +18,9 @@ module DecisionAgent
       # @param rule_content [Hash] The rule definition
       # @param created_by [String] User who created this version
       # @param changelog [String] Description of changes
+      # @param tag [String, nil] Optional tag name to apply to the new version at creation time
       # @return [Hash] The created version
-      def save_version(rule_id:, rule_content:, created_by: "system", changelog: nil)
+      def save_version(rule_id:, rule_content:, created_by: "system", changelog: nil, tag: nil)
         validate_rule_content!(rule_content)
 
         metadata = {
@@ -27,11 +28,15 @@ module DecisionAgent
           changelog: changelog || generate_default_changelog(rule_id)
         }
 
-        @adapter.create_version(
+        version = @adapter.create_version(
           rule_id: rule_id,
           content: rule_content,
           metadata: metadata
         )
+
+        tag!(rule_id, version[:id], tag) if tag
+
+        version
       end
 
       # Get all versions for a rule
@@ -107,6 +112,39 @@ module DecisionAgent
         @adapter.delete_version(version_id: version_id)
       end
 
+      # Tag a specific version after the fact.
+      # Creates the tag if it does not exist; re-points it if the name is already used.
+      # @param model_id [String] The rule/model identifier
+      # @param version_id [String] The version to tag
+      # @param name [String] The tag name
+      # @return [Hash] The tag ({ name:, version_id:, created_at: })
+      def tag!(model_id, version_id, name)
+        @adapter.create_tag(model_id: model_id, version_id: version_id, name: name)
+      end
+
+      # Resolve a tag to its version hash, or nil if the tag does not exist.
+      # @param model_id [String] The rule/model identifier
+      # @param name [String] The tag name
+      # @return [Hash, nil] Tag hash or nil
+      def get_tag(model_id:, name:)
+        @adapter.get_tag(model_id: model_id, name: name)
+      end
+
+      # List all tags for a model.
+      # @param model_id [String] The rule/model identifier
+      # @return [Array<Hash>] Tag hashes sorted by name
+      def list_tags(model_id:)
+        @adapter.list_tags(model_id: model_id)
+      end
+
+      # Delete a tag by name.
+      # @param model_id [String] The rule/model identifier
+      # @param name [String] The tag name
+      # @return [Boolean] True if deleted, false if the tag did not exist
+      def delete_tag(model_id:, name:)
+        @adapter.delete_tag(model_id: model_id, name: name)
+      end
+
       private
 
       def default_adapter

data/lib/decision_agent/web/dmn_editor.rb

@@ -70,14 +70,12 @@ module DecisionAgent
       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")
@@ -128,7 +126,6 @@ module DecisionAgent
       end
 
       # Delete a decision
-      # rubocop:disable Naming/PredicateMethod
       def delete_decision(model_id:, decision_id:)
         model = retrieve_model(model_id)
         return false unless model
@@ -137,7 +134,6 @@ module DecisionAgent
         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)
@@ -220,7 +216,6 @@ module DecisionAgent
       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
@@ -232,7 +227,6 @@ module DecisionAgent
         store_model(model_id, model)
         true
       end
-      # rubocop:enable Naming/PredicateMethod
 
       # Validate a DMN model
       def validate_model(model_id)