decision_agent 1.0.1 → 1.2.0

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 = "1.0.1".freeze
+  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

@@ -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_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
+        # 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
 
-        serialize_version(version)
+          serialize_version(version)
+        end
       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,25 +91,28 @@ 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_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
+        # 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)
 
-        serialize_version(version)
+            # 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
+
+          serialize_version(version)
+        end
       end
 
       def delete_version(version_id:)
@@ -116,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
@@ -128,6 +184,54 @@ 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)
+        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") ||
+                cause.class.name.include?("LockedException") ||
+                cause.class.name.include?("SQLite3::LockedException")
+            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?("database table is locked") ||
+                    e.message.include?("SQLite3::BusyException") ||
+                    e.message.include?("BusyException") ||
+                    e.message.include?("LockedException")
+
+          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
@@ -151,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

@@ -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
@@ -73,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

@@ -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
@@ -148,12 +159,52 @@ 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
           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 +269,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
@@ -240,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] }
@@ -255,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
@@ -353,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DecisionAgent
   module Versioning
     # High-level service for managing rule versions
@@ -16,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 = {
@@ -25,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
@@ -40,6 +47,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
@@ -98,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/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