decision_agent 0.1.1 → 0.1.3

data/lib/decision_agent/web/server.rb

@@ -12,7 +12,7 @@ module DecisionAgent
       # Enable CORS for API calls
       before do
         headers["Access-Control-Allow-Origin"] = "*"
-        headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+        headers["Access-Control-Allow-Methods"] = "GET, POST, DELETE, OPTIONS"
         headers["Access-Control-Allow-Headers"] = "Content-Type"
       end
 
@@ -43,14 +43,12 @@ module DecisionAgent
             valid: true,
             message: "Rules are valid!"
           }.to_json
-
         rescue JSON::ParserError => e
           status 400
           {
             valid: false,
             errors: ["Invalid JSON: #{e.message}"]
           }.to_json
-
         rescue DecisionAgent::InvalidRuleDslError => e
           # Validation failed
           status 422
@@ -58,8 +56,7 @@ module DecisionAgent
             valid: false,
             errors: parse_validation_errors(e.message)
           }.to_json
-
-        rescue => e
+        rescue StandardError => e
           # Unexpected error
           status 500
           {
@@ -102,8 +99,7 @@ module DecisionAgent
               message: "No rules matched the given context"
             }.to_json
           end
-
-        rescue => e
+        rescue StandardError => e
           status 500
           {
             success: false,
@@ -136,7 +132,7 @@ module DecisionAgent
                 },
                 {
                   id: "high_amount_review",
-                  if: { field: "amount", op: "gte", value: 10000 },
+                  if: { field: "amount", op: "gte", value: 10_000 },
                   then: { decision: "manual_review", weight: 0.9, reason: "High amount requires review" }
                 }
               ]
@@ -223,8 +219,164 @@ module DecisionAgent
         { status: "ok", version: DecisionAgent::VERSION }.to_json
       end
 
+      # Versioning API endpoints
+
+      # Create a new version
+      post "/api/versions" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          rule_id = data["rule_id"]
+          rule_content = data["content"]
+          created_by = data["created_by"] || "system"
+          changelog = data["changelog"]
+
+          version = version_manager.save_version(
+            rule_id: rule_id,
+            rule_content: rule_content,
+            created_by: created_by,
+            changelog: changelog
+          )
+
+          status 201
+          version.to_json
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # List all versions for a rule
+      get "/api/rules/:rule_id/versions" do
+        content_type :json
+
+        begin
+          rule_id = params[:rule_id]
+          limit = params[:limit]&.to_i
+
+          versions = version_manager.get_versions(rule_id: rule_id, limit: limit)
+
+          versions.to_json
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Get version history with metadata
+      get "/api/rules/:rule_id/history" do
+        content_type :json
+
+        begin
+          rule_id = params[:rule_id]
+          history = version_manager.get_history(rule_id: rule_id)
+
+          history.to_json
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Get a specific version
+      get "/api/versions/:version_id" do
+        content_type :json
+
+        begin
+          version_id = params[:version_id]
+          version = version_manager.get_version(version_id: version_id)
+
+          if version
+            version.to_json
+          else
+            status 404
+            { error: "Version not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Activate a version (rollback)
+      post "/api/versions/:version_id/activate" do
+        content_type :json
+
+        begin
+          version_id = params[:version_id]
+          request_body = request.body.read
+          data = request_body.empty? ? {} : JSON.parse(request_body)
+          performed_by = data["performed_by"] || "system"
+
+          version = version_manager.rollback(
+            version_id: version_id,
+            performed_by: performed_by
+          )
+
+          version.to_json
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Compare two versions
+      get "/api/versions/:version_id_1/compare/:version_id_2" do
+        content_type :json
+
+        begin
+          version_id_1 = params[:version_id_1]
+          version_id_2 = params[:version_id_2]
+
+          comparison = version_manager.compare(
+            version_id_1: version_id_1,
+            version_id_2: version_id_2
+          )
+
+          if comparison
+            comparison.to_json
+          else
+            status 404
+            { error: "One or both versions not found" }.to_json
+          end
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Delete a version
+      delete "/api/versions/:version_id" do
+        content_type :json
+
+        begin
+          version_id = params[:version_id]
+
+          version_manager.delete_version(version_id: version_id)
+
+          status 200
+          { success: true, message: "Version deleted successfully" }.to_json
+        rescue DecisionAgent::NotFoundError => e
+          status 404
+          { error: e.message }.to_json
+        rescue DecisionAgent::ValidationError => e
+          status 422
+          { error: e.message }.to_json
+        rescue StandardError => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
       private
 
+      def version_manager
+        @version_manager ||= DecisionAgent::Versioning::VersionManager.new
+      end
+
       def parse_validation_errors(error_message)
         # Extract individual errors from the formatted error message
         errors = []
@@ -244,12 +396,20 @@ module DecisionAgent
         errors.empty? ? [error_message] : errors
       end
 
-      # Class method to start the server
+      # Class method to start the server (for CLI usage)
       def self.start!(port: 4567, host: "0.0.0.0")
         set :port, port
         set :bind, host
         run!
       end
+
+      # Rack interface for mounting in Rails/Rack apps
+      # Example:
+      #   # config/routes.rb
+      #   mount DecisionAgent::Web::Server, at: "/decision_agent"
+      def self.call(env)
+        new.call(env)
+      end
     end
   end
 end

data/lib/decision_agent.rb

@@ -2,6 +2,7 @@ require_relative "decision_agent/version"
 require_relative "decision_agent/errors"
 require_relative "decision_agent/context"
 require_relative "decision_agent/evaluation"
+require_relative "decision_agent/evaluation_validator"
 require_relative "decision_agent/decision"
 require_relative "decision_agent/agent"
 
@@ -25,5 +26,15 @@ require_relative "decision_agent/audit/logger_adapter"
 
 require_relative "decision_agent/replay/replay"
 
+require_relative "decision_agent/versioning/adapter"
+require_relative "decision_agent/versioning/file_storage_adapter"
+require_relative "decision_agent/versioning/version_manager"
+
+require_relative "decision_agent/monitoring/metrics_collector"
+require_relative "decision_agent/monitoring/prometheus_exporter"
+require_relative "decision_agent/monitoring/alert_manager"
+require_relative "decision_agent/monitoring/monitored_agent"
+# dashboard_server has additional dependencies (faye/websocket) - require it explicitly when needed
+
 module DecisionAgent
 end

data/lib/generators/decision_agent/install/install_generator.rb

@@ -0,0 +1,40 @@
+require "rails/generators"
+require "rails/generators/migration"
+
+module DecisionAgent
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs DecisionAgent models and migrations for Rails"
+
+      def self.next_migration_number(dirname)
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def copy_migration
+        migration_template "migration.rb",
+                           "db/migrate/create_decision_agent_tables.rb",
+                           migration_version: migration_version
+      end
+
+      def copy_models
+        copy_file "rule.rb", "app/models/rule.rb"
+        copy_file "rule_version.rb", "app/models/rule_version.rb"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+
+      private
+
+      def migration_version
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/decision_agent/install/templates/README

@@ -0,0 +1,47 @@
+===============================================================================
+
+DecisionAgent has been installed!
+
+Next steps:
+
+1. Run the migrations:
+
+   rails db:migrate
+
+2. The following models have been created:
+   - Rule (app/models/rule.rb)
+   - RuleVersion (app/models/rule_version.rb)
+
+3. Start using the versioning system:
+
+   # Create a rule with a version
+   rule = Rule.create!(
+     rule_id: 'approval_rule_001',
+     ruleset: 'approval',
+     description: 'Approval decision rules'
+   )
+
+   # Create a version
+   rule.create_version(
+     content: { /* your rule JSON */ },
+     created_by: 'admin',
+     changelog: 'Initial version'
+   )
+
+   # Or use the VersionManager directly
+   manager = DecisionAgent::Versioning::VersionManager.new
+   manager.save_version(
+     rule_id: 'approval_rule_001',
+     rule_content: { /* your rule JSON */ },
+     created_by: 'admin'
+   )
+
+4. Optional: Mount the DecisionAgent routes in config/routes.rb:
+
+   # This is planned for a future release
+   # mount DecisionAgent::Engine => '/decision_agent'
+
+For more information, visit:
+https://github.com/samaswin87/decision_agent
+
+===============================================================================

data/lib/generators/decision_agent/install/templates/migration.rb

@@ -0,0 +1,37 @@
+class CreateDecisionAgentTables < ActiveRecord::Migration[7.0]
+  def change
+    # Rules table
+    create_table :rules do |t|
+      t.string :rule_id, null: false, index: { unique: true }
+      t.string :ruleset, null: false
+      t.text :description
+      t.string :status, default: "active"
+      t.timestamps
+    end
+
+    # Rule versions table
+    create_table :rule_versions do |t|
+      t.string :rule_id, null: false, index: true
+      t.integer :version_number, null: false
+      t.text :content, null: false # JSON rule definition
+      t.string :created_by, null: false, default: "system"
+      t.text :changelog
+      t.string :status, null: false, default: "draft" # draft, active, archived
+      t.timestamps
+    end
+
+    # ✅ CRITICAL: Unique constraint prevents duplicate version numbers per rule
+    # This protects against race conditions in concurrent version creation
+    add_index :rule_versions, %i[rule_id version_number], unique: true
+
+    # Index for efficient queries by rule_id and status
+    add_index :rule_versions, %i[rule_id status]
+
+    # Optional: Partial unique index for PostgreSQL to enforce one active version per rule
+    # Uncomment if using PostgreSQL:
+    # add_index :rule_versions, [:rule_id, :status],
+    #           unique: true,
+    #           where: "status = 'active'",
+    #           name: 'index_rule_versions_one_active_per_rule'
+  end
+end

data/lib/generators/decision_agent/install/templates/rule.rb

@@ -0,0 +1,30 @@
+class Rule < ApplicationRecord
+  has_many :rule_versions, primary_key: :rule_id, foreign_key: :rule_id, dependent: :destroy
+
+  validates :rule_id, presence: true, uniqueness: true
+  validates :ruleset, presence: true
+  validates :status, inclusion: { in: %w[active inactive archived] }
+
+  scope :active, -> { where(status: "active") }
+  scope :by_ruleset, ->(ruleset) { where(ruleset: ruleset) }
+
+  # Get the active version for this rule
+  def active_version
+    rule_versions.find_by(status: "active")
+  end
+
+  # Get all versions ordered by version number
+  def versions
+    rule_versions.order(version_number: :desc)
+  end
+
+  # Create a new version
+  def create_version(content:, created_by: "system", changelog: nil)
+    DecisionAgent::Versioning::VersionManager.new.save_version(
+      rule_id: rule_id,
+      rule_content: content,
+      created_by: created_by,
+      changelog: changelog
+    )
+  end
+end

data/lib/generators/decision_agent/install/templates/rule_version.rb

@@ -0,0 +1,66 @@
+class RuleVersion < ApplicationRecord
+  belongs_to :rule, primary_key: :rule_id, foreign_key: :rule_id, optional: true
+
+  validates :rule_id, presence: true
+  validates :version_number, presence: true, uniqueness: { scope: :rule_id }
+  validates :content, presence: true
+  validates :status, inclusion: { in: %w[draft active archived] }
+  validates :created_by, presence: true
+
+  scope :active, -> { where(status: "active") }
+  scope :for_rule, ->(rule_id) { where(rule_id: rule_id).order(version_number: :desc) }
+  scope :latest, -> { order(version_number: :desc).limit(1) }
+
+  before_create :set_next_version_number
+
+  # Parse the JSON content
+  def parsed_content
+    JSON.parse(content, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+
+  # Set content from a hash
+  def content_hash=(hash)
+    self.content = hash.to_json
+  end
+
+  # Activate this version (deactivates others)
+  def activate!
+    transaction do
+      # Deactivate all other versions for this rule
+      # Use update! instead of update_all to trigger validations
+      self.class.where(rule_id: rule_id, status: "active")
+          .where.not(id: id)
+          .find_each do |v|
+        v.update!(status: "archived")
+      end
+
+      # Activate this version
+      update!(status: "active")
+    end
+  end
+
+  # Compare with another version
+  def compare_with(other_version)
+    DecisionAgent::Versioning::VersionManager.new.compare(
+      version_id_1: id,
+      version_id_2: other_version.id
+    )
+  end
+
+  private
+
+  def set_next_version_number
+    return if version_number.present?
+
+    # Use pessimistic locking to prevent race conditions when calculating version numbers
+    # Lock the last version record to ensure only one thread can read and increment at a time
+    last_version = self.class.where(rule_id: rule_id)
+                       .order(version_number: :desc)
+                       .lock
+                       .first
+
+    self.version_number = last_version ? last_version.version_number + 1 : 1
+  end
+end