decision_agent 0.1.1 → 0.1.2

data/bin/decision_agent

@@ -29,6 +29,11 @@ def print_help
 end
 
 def start_web_ui(port = 4567)
+  # Ruby 4.0 compatibility: Puma expects Bundler::ORIGINAL_ENV which was removed
+  if defined?(Bundler) && !Bundler.const_defined?(:ORIGINAL_ENV)
+    Bundler.const_set(:ORIGINAL_ENV, ENV.to_h.dup)
+  end
+
   puts "🎯 Starting DecisionAgent Rule Builder..."
   puts "📍 Server: http://localhost:#{port}"
   puts "⚡️ Press Ctrl+C to stop"

data/lib/decision_agent/errors.rb

@@ -59,4 +59,16 @@ module DecisionAgent
       super("Weight must be between 0.0 and 1.0, got: #{weight}")
     end
   end
+
+  class NotFoundError < Error
+    def initialize(message = "Resource not found")
+      super(message)
+    end
+  end
+
+  class ValidationError < Error
+    def initialize(message = "Validation failed")
+      super(message)
+    end
+  end
 end

data/lib/decision_agent/version.rb

@@ -1,3 +1,3 @@
 module DecisionAgent
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/decision_agent/versioning/activerecord_adapter.rb

@@ -0,0 +1,105 @@
+require_relative "adapter"
+
+module DecisionAgent
+  module Versioning
+    # ActiveRecord-based version storage adapter for Rails applications
+    # Requires ActiveRecord models to be set up in the Rails app
+    class ActiveRecordAdapter < Adapter
+      def initialize
+        unless defined?(ActiveRecord)
+          raise DecisionAgent::ConfigurationError,
+                "ActiveRecord is not available. Please ensure Rails/ActiveRecord is loaded."
+        end
+      end
+
+      def create_version(rule_id:, content:, metadata: {})
+        # Get the next version number for this rule
+        last_version = rule_version_class.where(rule_id: rule_id)
+                                        .order(version_number: :desc)
+                                        .first
+        next_version_number = last_version ? last_version.version_number + 1 : 1
+
+        # Deactivate previous active versions
+        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: metadata[:status] || "active"
+        )
+
+        serialize_version(version)
+      end
+
+      def list_versions(rule_id:, limit: nil)
+        query = rule_version_class.where(rule_id: rule_id)
+                                  .order(version_number: :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
+      end
+
+      def get_version_by_number(rule_id:, version_number:)
+        version = rule_version_class.find_by(
+          rule_id: rule_id,
+          version_number: version_number
+        )
+        version ? serialize_version(version) : nil
+      end
+
+      def get_active_version(rule_id:)
+        version = rule_version_class.find_by(rule_id: rule_id, status: "active")
+        version ? serialize_version(version) : nil
+      end
+
+      def activate_version(version_id:)
+        version = rule_version_class.find(version_id)
+
+        # Deactivate all other versions for this rule
+        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")
+
+        serialize_version(version)
+      end
+
+      private
+
+      def rule_version_class
+        # Look for the RuleVersion model in the main app
+        if defined?(::RuleVersion)
+          ::RuleVersion
+        else
+          raise DecisionAgent::ConfigurationError,
+                "RuleVersion model not found. Please run the generator to create it."
+        end
+      end
+
+      def serialize_version(version)
+        {
+          id: version.id,
+          rule_id: version.rule_id,
+          version_number: version.version_number,
+          content: JSON.parse(version.content),
+          created_by: version.created_by,
+          created_at: version.created_at,
+          changelog: version.changelog,
+          status: version.status
+        }
+      end
+    end
+  end
+end

data/lib/decision_agent/versioning/adapter.rb

@@ -0,0 +1,102 @@
+module DecisionAgent
+  module Versioning
+    # Abstract base class for version storage adapters
+    # Allows framework-agnostic versioning with pluggable storage backends
+    class Adapter
+      # Create a new version for a rule
+      # @param rule_id [String] Unique identifier for the rule
+      # @param content [Hash] Rule definition as a hash
+      # @param metadata [Hash] Additional metadata (created_by, changelog, etc.)
+      # @return [Hash] The created version
+      def create_version(rule_id:, content:, metadata: {})
+        raise NotImplementedError, "#{self.class} must implement #create_version"
+      end
+
+      # List all versions for a specific rule
+      # @param rule_id [String] The rule identifier
+      # @param limit [Integer, nil] Optional limit for number of versions
+      # @return [Array<Hash>] Array of version hashes
+      def list_versions(rule_id:, limit: nil)
+        raise NotImplementedError, "#{self.class} must implement #list_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
+      def get_version(version_id:)
+        raise NotImplementedError, "#{self.class} must implement #get_version"
+      end
+
+      # Get a specific version by rule_id and version_number
+      # @param rule_id [String] The rule identifier
+      # @param version_number [Integer] The version number
+      # @return [Hash, nil] The version hash or nil if not found
+      def get_version_by_number(rule_id:, version_number:)
+        raise NotImplementedError, "#{self.class} must implement #get_version_by_number"
+      end
+
+      # Get the active version for a rule
+      # @param rule_id [String] The rule identifier
+      # @return [Hash, nil] The active version or nil
+      def get_active_version(rule_id:)
+        raise NotImplementedError, "#{self.class} must implement #get_active_version"
+      end
+
+      # Activate a specific version
+      # @param version_id [String, Integer] The version to activate
+      # @return [Hash] The activated version
+      def activate_version(version_id:)
+        raise NotImplementedError, "#{self.class} must implement #activate_version"
+      end
+
+      # Compare two versions
+      # @param version_id_1 [String, Integer] First version ID
+      # @param version_id_2 [String, Integer] Second version ID
+      # @return [Hash] Comparison result with differences
+      def compare_versions(version_id_1:, version_id_2:)
+        v1 = get_version(version_id: version_id_1)
+        v2 = get_version(version_id: version_id_2)
+
+        return nil if v1.nil? || v2.nil?
+
+        {
+          version_1: v1,
+          version_2: v2,
+          differences: calculate_diff(v1[:content], v2[:content])
+        }
+      end
+
+      # Delete a specific version
+      # @param version_id [String, Integer] The version to delete
+      # @return [Boolean] True if deleted successfully
+      def delete_version(version_id:)
+        raise NotImplementedError, "#{self.class} must implement #delete_version"
+      end
+
+      private
+
+      # Calculate differences between two content hashes
+      # @param content1 [Hash] First content
+      # @param content2 [Hash] Second content
+      # @return [Hash] Differences
+      def calculate_diff(content1, content2)
+        {
+          added: content2.to_a - content1.to_a,
+          removed: content1.to_a - content2.to_a,
+          changed: detect_changes(content1, content2)
+        }
+      end
+
+      def detect_changes(hash1, hash2)
+        changes = {}
+        hash1.each do |key, value1|
+          value2 = hash2[key]
+          if value1 != value2 && !value2.nil?
+            changes[key] = { old: value1, new: value2 }
+          end
+        end
+        changes
+      end
+    end
+  end
+end

data/lib/decision_agent/versioning/file_storage_adapter.rb

@@ -0,0 +1,182 @@
+require_relative "adapter"
+require "json"
+require "fileutils"
+
+module DecisionAgent
+  module Versioning
+    # File-based version storage adapter for non-Rails applications
+    # Stores versions as JSON files in a directory structure
+    class FileStorageAdapter < Adapter
+      attr_reader :storage_path
+
+      # Initialize with a storage directory
+      # @param storage_path [String] Path to store version files (default: ./versions)
+      def initialize(storage_path: "./versions")
+        @storage_path = storage_path
+        @mutex = Mutex.new
+        FileUtils.mkdir_p(@storage_path)
+      end
+
+      def create_version(rule_id:, content:, metadata: {})
+        @mutex.synchronize do
+          create_version_unsafe(rule_id: rule_id, content: content, metadata: metadata)
+        end
+      end
+
+      private
+
+      def create_version_unsafe(rule_id:, content:, metadata: {})
+        # Get the next version number
+        versions = list_versions(rule_id: rule_id)
+        next_version_number = versions.empty? ? 1 : versions.first[:version_number] + 1
+
+        # Deactivate previous active versions
+        versions.each do |v|
+          if v[:status] == "active"
+            update_version_status(v[:id], "archived")
+          end
+        end
+
+        # Create version data
+        version_id = generate_version_id(rule_id, next_version_number)
+        version = {
+          id: version_id,
+          rule_id: rule_id,
+          version_number: next_version_number,
+          content: content,
+          created_by: metadata[:created_by] || "system",
+          created_at: Time.now.utc.iso8601,
+          changelog: metadata[:changelog] || "Version #{next_version_number}",
+          status: metadata[:status] || "active"
+        }
+
+        # Write to file
+        write_version_file(version)
+
+        version
+      end
+
+      public
+
+      def list_versions(rule_id:, limit: nil)
+        versions = []
+        rule_dir = File.join(@storage_path, sanitize_filename(rule_id))
+
+        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)
+        end
+
+        versions.sort_by! { |v| -v[:version_number] }
+        limit ? versions.take(limit) : versions
+      end
+
+      def get_version(version_id:)
+        all_versions.find { |v| v[:id] == version_id }
+      end
+
+      def get_version_by_number(rule_id:, version_number:)
+        versions = list_versions(rule_id: rule_id)
+        versions.find { |v| v[:version_number] == version_number }
+      end
+
+      def get_active_version(rule_id:)
+        versions = list_versions(rule_id: rule_id)
+        versions.find { |v| v[:status] == "active" }
+      end
+
+      def activate_version(version_id:)
+        @mutex.synchronize do
+          version = get_version(version_id: version_id)
+          raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless version
+
+          # Deactivate all other versions for this rule
+          list_versions(rule_id: version[:rule_id]).each do |v|
+            if v[:id] != version_id && v[:status] == "active"
+              update_version_status(v[:id], "archived")
+            end
+          end
+
+          # Activate this version
+          version[:status] = "active"
+          write_version_file(version)
+
+          version
+        end
+      end
+
+      def delete_version(version_id:)
+        @mutex.synchronize do
+          version = get_version(version_id: version_id)
+          raise DecisionAgent::NotFoundError, "Version not found: #{version_id}" unless version
+
+          # Prevent deletion of active versions
+          if version[:status] == "active"
+            raise DecisionAgent::ValidationError, "Cannot delete active version. Please activate another version first."
+          end
+
+          # Delete the file
+          rule_dir = File.join(@storage_path, sanitize_filename(version[:rule_id]))
+          filename = "#{version[:version_number]}.json"
+          filepath = File.join(rule_dir, filename)
+
+          if File.exist?(filepath)
+            File.delete(filepath)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      private
+
+      def all_versions
+        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)
+        end
+
+        versions
+      end
+
+      def update_version_status(version_id, status)
+        version = get_version(version_id: version_id)
+        return unless version
+
+        version[:status] = status
+        write_version_file(version)
+      end
+
+      def write_version_file(version)
+        rule_dir = File.join(@storage_path, sanitize_filename(version[:rule_id]))
+        FileUtils.mkdir_p(rule_dir)
+
+        filename = "#{version[:version_number]}.json"
+        filepath = File.join(rule_dir, filename)
+
+        # Use atomic write to prevent race conditions during concurrent access
+        # Write to temp file first, then atomically rename
+        temp_file = "#{filepath}.tmp.#{Process.pid}.#{Thread.current.object_id}"
+        begin
+          File.write(temp_file, JSON.pretty_generate(version))
+          File.rename(temp_file, filepath)
+        ensure
+          # Clean up temp file if rename failed
+          File.delete(temp_file) if File.exist?(temp_file)
+        end
+      end
+
+      def generate_version_id(rule_id, version_number)
+        "#{rule_id}_v#{version_number}"
+      end
+
+      def sanitize_filename(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
+      end
+    end
+  end
+end

data/lib/decision_agent/versioning/version_manager.rb

@@ -0,0 +1,135 @@
+module DecisionAgent
+  module Versioning
+    # High-level service for managing rule versions
+    # Provides a framework-agnostic API using pluggable storage adapters
+    class VersionManager
+      attr_reader :adapter
+
+      # Initialize with a storage adapter
+      # @param adapter [Adapter] The storage adapter to use
+      def initialize(adapter: nil)
+        @adapter = adapter || default_adapter
+      end
+
+      # Save a new version of a rule
+      # @param rule_id [String] Unique identifier for the rule
+      # @param rule_content [Hash] The rule definition
+      # @param created_by [String] User who created this version
+      # @param changelog [String] Description of changes
+      # @return [Hash] The created version
+      def save_version(rule_id:, rule_content:, created_by: "system", changelog: nil)
+        validate_rule_content!(rule_content)
+
+        metadata = {
+          created_by: created_by,
+          changelog: changelog || generate_default_changelog(rule_id)
+        }
+
+        @adapter.create_version(
+          rule_id: rule_id,
+          content: rule_content,
+          metadata: metadata
+        )
+      end
+
+      # Get all versions for a rule
+      # @param rule_id [String] The rule identifier
+      # @param limit [Integer, nil] Optional limit
+      # @return [Array<Hash>] Array of versions
+      def get_versions(rule_id:, limit: nil)
+        @adapter.list_versions(rule_id: rule_id, limit: limit)
+      end
+
+      # Get a specific version
+      # @param version_id [String, Integer] The version identifier
+      # @return [Hash, nil] The version or nil
+      def get_version(version_id:)
+        @adapter.get_version(version_id: version_id)
+      end
+
+      # Get the currently active version for a rule
+      # @param rule_id [String] The rule identifier
+      # @return [Hash, nil] The active version or nil
+      def get_active_version(rule_id:)
+        @adapter.get_active_version(rule_id: rule_id)
+      end
+
+      # Rollback to a previous version (activate it)
+      # @param version_id [String, Integer] The version to rollback to
+      # @param performed_by [String] User performing the rollback
+      # @return [Hash] The activated version
+      def rollback(version_id:, performed_by: "system")
+        version = @adapter.activate_version(version_id: version_id)
+
+        # Create an audit trail of the rollback
+        save_version(
+          rule_id: version[:rule_id],
+          rule_content: version[:content],
+          created_by: performed_by,
+          changelog: "Rolled back to version #{version[:version_number]}"
+        )
+
+        version
+      end
+
+      # Compare two versions
+      # @param version_id_1 [String, Integer] First version
+      # @param version_id_2 [String, Integer] Second version
+      # @return [Hash] Comparison result
+      def compare(version_id_1:, version_id_2:)
+        @adapter.compare_versions(
+          version_id_1: version_id_1,
+          version_id_2: version_id_2
+        )
+      end
+
+      # Get version history with metadata
+      # @param rule_id [String] The rule identifier
+      # @return [Hash] History with statistics
+      def get_history(rule_id:)
+        versions = get_versions(rule_id: rule_id)
+
+        {
+          rule_id: rule_id,
+          total_versions: versions.length,
+          active_version: get_active_version(rule_id: rule_id),
+          versions: versions,
+          created_at: versions.last&.dig(:created_at),
+          updated_at: versions.first&.dig(:created_at)
+        }
+      end
+
+      # Delete a specific version
+      # @param version_id [String, Integer] The version to delete
+      # @return [Boolean] True if deleted successfully
+      def delete_version(version_id:)
+        @adapter.delete_version(version_id: version_id)
+      end
+
+      private
+
+      def default_adapter
+        # Auto-detect the best adapter based on available frameworks
+        if defined?(ActiveRecord) && defined?(::RuleVersion)
+          require_relative "activerecord_adapter"
+          ActiveRecordAdapter.new
+        else
+          require_relative "file_storage_adapter"
+          FileStorageAdapter.new
+        end
+      end
+
+      def validate_rule_content!(content)
+        raise DecisionAgent::ValidationError, "Rule content cannot be nil" if content.nil?
+        raise DecisionAgent::ValidationError, "Rule content must be a Hash" unless content.is_a?(Hash)
+        raise DecisionAgent::ValidationError, "Rule content cannot be empty" if content.empty?
+      end
+
+      def generate_default_changelog(rule_id)
+        versions = get_versions(rule_id: rule_id)
+        version_num = versions.empty? ? 1 : versions.first[:version_number] + 1
+        "Version #{version_num}"
+      end
+    end
+  end
+end