activematrix 0.0.4 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f0db6dac569a30cc870826d01a99877b7f565c70c91807d3e6060dc07af8a9b
-  data.tar.gz: db8b7398c33b5218e53e46110279854ea8e919315d2c40f70641075765a7f3fd
+  metadata.gz: 9bf1ad81648f055b2fdb10da688c66ac7267456cea155b0d76bb41864ae6bab5
+  data.tar.gz: 282f29e6c278cc4ee5b721039e1ec36c2a48b03ba115e02e9beb017b45211706
 SHA512:
-  metadata.gz: 21bd2769dcce98268e832a2ba4479f38e48e567598c41ab1fc0c18aac73ca448e3805cdc266a4db1b126f3b146e8e2fba70dcf159d635d671f3a39b8e8c73c14
-  data.tar.gz: edd3589aa53ded85318976e2cedddcba921c187cf831373a764aebc3b190cb65d84a4dcd27e659ec21daecda2b63a4485d87d6975151cc4944aba88771a770f3
+  metadata.gz: '08aedb897355151e41f5db2b169d58d0b2842b0c5b7c51a596708ab8ce60be886cb99550f7bb7dfdbf1e71fae918014489d4c48d4271077b930765f6513e28b6'
+  data.tar.gz: b6a3e216fecc58cf8416bc84980c7e5c17edff2b971a2707ee9f82740c69518b60a77880440522765f4befc8a1fc2fc7bb81df39e8fc120c7ddc4451c4368908

data/app/jobs/active_matrix/application_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class ApplicationJob < ActiveJob::Base
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+  end
+end

data/app/models/active_matrix/agent/jobs/memory_reaper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class Agent < ApplicationRecord
+    module Jobs
+      # Background job responsible for harvesting dead agent memories from the system.
+      #
+      # This job systematically harvests dead memory entries to prevent database bloat
+      # and maintain optimal performance. It operates as a scheduled reaper process
+      # that runs automatically when agent memories reach their expiration time.
+      #
+      # The job performs the following operations:
+      # 1. Identifies dead agent memory records based on their expires_at timestamp
+      # 2. Harvests dead entries from both database and cache layers
+      # 3. Logs harvesting statistics for monitoring and debugging purposes
+      # 4. Handles harvesting failures gracefully without affecting system stability
+      #
+      # Usage:
+      #   # Schedule immediate harvesting
+      #   ActiveMatrix::Agent::Jobs::MemoryReaper.perform_later
+      #
+      #   # Schedule harvesting for specific time
+      #   ActiveMatrix::Agent::Jobs::MemoryReaper.set(wait_until: 1.hour.from_now).perform_later
+      #
+      class MemoryReaper < ActiveMatrix::ApplicationJob
+        queue_as :maintenance
+
+        # Performs the memory reaping operation with comprehensive error handling
+        def perform
+          ActiveMatrix.logger.info 'Starting agent memory reaping operation'
+
+          reaping_stats = {
+            agent_memories_reaped: 0,
+            cache_entries_cleared: 0,
+            errors_encountered: 0
+          }
+
+          begin
+            # Harvest dead agent memories
+            reaping_stats[:agent_memories_reaped] = harvest_dead_agent_memories
+
+            # Clear associated cache entries
+            reaping_stats[:cache_entries_cleared] = clear_expired_cache_entries
+
+            ActiveMatrix.logger.info "Memory reaping completed successfully: #{reaping_stats}"
+          rescue StandardError => e
+            reaping_stats[:errors_encountered] += 1
+            ActiveMatrix.logger.error "Memory reaping failed: #{e.message}"
+            ActiveMatrix.logger.error e.backtrace.join("\n")
+
+            # Re-raise to ensure job is marked as failed for retry
+            raise e
+          end
+
+          reaping_stats
+        end
+
+        private
+
+        # Harvests dead agent memory records from the database
+        # Returns the number of records harvested
+        def harvest_dead_agent_memories
+          return 0 unless defined?(ActiveMatrix::AgentStore)
+
+          dead_memories = ActiveMatrix::AgentStore.expired
+          count = dead_memories.count
+
+          if count.positive?
+            ActiveMatrix.logger.debug "Harvesting #{count} dead agent memory records"
+            dead_memories.destroy_all
+          end
+
+          count
+        end
+
+        # Clears expired memory entries from the Rails cache
+        # Returns the number of cache entries cleared
+        def clear_expired_cache_entries
+          # NOTE: Rails.cache doesn't provide a direct way to clear expired entries
+          # This is a placeholder for cache-specific cleanup logic if needed
+          # Most cache stores handle expiration automatically
+          0
+        end
+      end
+    end
+  end
+end

data/app/models/active_matrix/agent.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class Agent < ApplicationRecord
+    self.table_name = 'active_matrix_agents'
+
+    # Associations
+    has_many :agent_stores, class_name: 'ActiveMatrix::AgentStore', dependent: :destroy
+    has_many :chat_sessions, class_name: 'ActiveMatrix::ChatSession', dependent: :destroy
+
+    # Validations
+    validates :name, presence: true, uniqueness: true
+    validates :homeserver, presence: true
+    validates :username, presence: true
+    validates :bot_class, presence: true
+    validate :valid_bot_class?
+
+    # Scopes
+    scope :active, -> { where.not(state: %i[offline error]) }
+    scope :online, -> { where(state: %i[online_idle online_busy]) }
+    scope :offline, -> { where(state: :offline) }
+
+    # Encrypts password before saving
+    before_save :encrypt_password, if: :password_changed?
+
+    # State machine for agent lifecycle
+    state_machine :state, initial: :offline do
+      state :offline
+      state :connecting
+      state :online_idle
+      state :online_busy
+      state :error
+      state :paused
+
+      event :connect do
+        transition %i[offline error paused] => :connecting
+      end
+
+      event :connection_established do
+        transition connecting: :online_idle
+      end
+
+      after_transition to: :online_idle do |agent|
+        agent.update(last_active_at: Time.current)
+      end
+
+      event :start_processing do
+        transition online_idle: :online_busy
+      end
+
+      event :finish_processing do
+        transition online_busy: :online_idle
+      end
+
+      event :disconnect do
+        transition %i[connecting online_idle online_busy] => :offline
+      end
+
+      event :encounter_error do
+        transition any => :error
+      end
+
+      event :pause do
+        transition %i[online_idle online_busy] => :paused
+      end
+
+      event :resume do
+        transition paused: :connecting
+      end
+    end
+
+    # Instance methods
+    def bot_instance
+      @bot_instance ||= bot_class.constantize.new(client) if running?
+    end
+
+    def client
+      @client ||= if access_token.present?
+                    ActiveMatrix::Client.new(homeserver, access_token: access_token)
+                  else
+                    ActiveMatrix::Client.new(homeserver)
+                  end
+    end
+
+    def running?
+      %i[online_idle online_busy].include?(state.to_sym)
+    end
+
+    def memory
+      @memory ||= ActiveMatrix::Memory::AgentMemory.new(self)
+    end
+
+    def increment_messages_handled!
+      update!(messages_handled: messages_handled + 1)
+    end
+
+    def update_activity!
+      update(last_active_at: Time.current)
+    end
+
+    # Password handling
+    attr_accessor :password
+
+    def authenticate(password)
+      return false if encrypted_password.blank?
+
+      BCrypt::Password.new(encrypted_password) == password
+    end
+
+    private
+
+    def password_changed?
+      password.present?
+    end
+
+    def encrypt_password
+      self.encrypted_password = BCrypt::Password.create(password) if password.present?
+    end
+
+    def valid_bot_class?
+      return false if bot_class.blank?
+
+      begin
+        klass = bot_class.constantize
+        errors.add(:bot_class, 'must inherit from ActiveMatrix::Bot::Base') unless klass < ActiveMatrix::Bot::Base
+      rescue NameError
+        errors.add(:bot_class, 'must be a valid class name')
+      end
+    end
+  end
+end

data/app/models/active_matrix/agent_store.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class AgentStore < ApplicationRecord
+    self.table_name = 'active_matrix_agent_stores'
+
+    belongs_to :agent, class_name: 'ActiveMatrix::Agent'
+
+    validates :key, presence: true, uniqueness: { scope: :agent_id }
+
+    scope :active, -> { where('expires_at IS NULL OR expires_at > ?', Time.current) }
+    scope :expired, -> { where(expires_at: ..Time.current) }
+
+    # Automatically clean up expired memories
+    after_commit :schedule_cleanup, if: :expires_at?
+
+    def expired?
+      expires_at.present? && expires_at <= Time.current
+    end
+
+    def ttl=(seconds)
+      self.expires_at = seconds.present? ? Time.current + seconds : nil
+    end
+
+    def ttl
+      return nil if expires_at.blank?
+
+      remaining = expires_at - Time.current
+      [remaining, 0].max
+    end
+
+    # Cache integration
+    def cache_key
+      "agent_memory/#{agent_id}/#{key}"
+    end
+
+    def write_to_cache
+      Rails.cache.write(cache_key, value, expires_in: ttl)
+    end
+
+    def self.cleanup_expired!
+      expired.destroy_all
+    end
+
+    private
+
+    def schedule_cleanup
+      ActiveMatrix::Agent::Jobs::MemoryReaper.set(wait_until: expires_at).perform_later if defined?(ActiveMatrix::Agent::Jobs::MemoryReaper)
+    end
+  end
+end

data/app/models/active_matrix/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/active_matrix/chat_session.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class ChatSession < ApplicationRecord
+    self.table_name = 'active_matrix_chat_sessions'
+
+    belongs_to :agent, class_name: 'ActiveMatrix::Agent'
+
+    validates :user_id, presence: true
+    validates :room_id, presence: true
+    validates :user_id, uniqueness: { scope: %i[agent_id room_id] }
+
+    # Configuration
+    MAX_HISTORY_SIZE = 20
+
+    # Scopes
+    scope :recent, -> { order(last_message_at: :desc) }
+    scope :active, -> { where('last_message_at > ?', 1.hour.ago) }
+    scope :stale, -> { where(last_message_at: ...1.day.ago) }
+
+    # Add a message to the history
+    def add_message(message_data)
+      messages = message_history['messages'] || []
+
+      # Add new message
+      messages << {
+        'event_id' => message_data[:event_id],
+        'sender' => message_data[:sender],
+        'content' => message_data[:content],
+        'timestamp' => message_data[:timestamp] || Time.current.to_i
+      }
+
+      # Keep only recent messages
+      messages = messages.last(MAX_HISTORY_SIZE)
+
+      # Update record
+      self.message_history = { 'messages' => messages }
+      self.last_message_at = Time.current
+      self.message_count = messages.size
+      save!
+
+      # Update cache
+      write_to_cache
+    end
+
+    # Get recent messages
+    def recent_messages(limit = 10)
+      messages = message_history['messages'] || []
+      messages.last(limit)
+    end
+
+    # Clear old messages but keep context
+    def prune_history!
+      messages = message_history['messages'] || []
+      self.message_history = { 'messages' => messages.last(5) }
+      save!
+    end
+
+    # Cache integration
+    def cache_key
+      "conversation/#{agent_id}/#{user_id}/#{room_id}"
+    end
+
+    def write_to_cache
+      Rails.cache.write(cache_key, {
+                          context: context,
+                          recent_messages: recent_messages,
+                          last_message_at: last_message_at
+                        }, expires_in: 1.hour)
+    end
+
+    def self.cleanup_stale!
+      stale.destroy_all
+    end
+  end
+end

data/app/models/active_matrix/knowledge_base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  class KnowledgeBase < ApplicationRecord
+    self.table_name = 'active_matrix_knowledge_bases'
+
+    validates :key, presence: true, uniqueness: true
+
+    scope :active, -> { where('expires_at IS NULL OR expires_at > ?', Time.current) }
+    scope :expired, -> { where(expires_at: ..Time.current) }
+    scope :by_category, ->(category) { where(category: category) }
+    scope :readable, -> { where(public_read: true) }
+    scope :writable, -> { where(public_write: true) }
+
+    def expired?
+      expires_at.present? && expires_at <= Time.current
+    end
+
+    def readable_by?(agent)
+      public_read || (agent.is_a?(ActiveMatrix::Agent) && agent.admin?)
+    end
+
+    def writable_by?(agent)
+      public_write || (agent.is_a?(ActiveMatrix::Agent) && agent.admin?)
+    end
+
+    # Cache integration
+    def cache_key
+      "global/#{key}"
+    end
+
+    def write_to_cache
+      return unless active?
+
+      ttl = expires_at.present? ? expires_at - Time.current : nil
+      Rails.cache.write(cache_key, value, expires_in: ttl)
+    end
+
+    def self.get(key)
+      # Try cache first
+      cached = Rails.cache.read("global/#{key}")
+      return cached if cached.present?
+
+      # Fallback to database
+      memory = find_by(key: key)
+      return unless memory&.active?
+
+      memory.write_to_cache
+      memory.value
+    end
+
+    def self.set(key, value, category: nil, expires_in: nil, public_read: true, public_write: false)
+      memory = find_or_initialize_by(key: key)
+      memory.value = value
+      memory.category = category
+      memory.expires_at = expires_in.present? ? Time.current + expires_in : nil
+      memory.public_read = public_read
+      memory.public_write = public_write
+      memory.save!
+      memory.write_to_cache
+      memory
+    end
+
+    def self.cleanup_expired!
+      expired.destroy_all
+    end
+
+    private
+
+    def active?
+      !expired?
+    end
+  end
+end

data/lib/active_matrix/engine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rails/engine'
+
+module ActiveMatrix
+  class Engine < Rails::Engine
+    engine_name 'activematrix'
+
+    initializer 'activematrix.configure_logger' do
+      # Configure logger
+      ActiveMatrix.logger = Rails.logger
+    end
+  end
+end