activematrix 0.0.4 → 0.0.7

data/lib/generators/active_matrix/install/templates/conversation_context.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-class ConversationContext < ApplicationRecord
-  belongs_to :matrix_agent
-
-  validates :user_id, presence: true
-  validates :room_id, presence: true
-  validates :user_id, uniqueness: { scope: %i[matrix_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/#{matrix_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

data/lib/generators/active_matrix/install/templates/global_memory.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-class GlobalMemory < ApplicationRecord
-  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?(MatrixAgent) && agent.admin?)
-  end
-
-  def writable_by?(agent)
-    public_write || (agent.is_a?(MatrixAgent) && 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

data/lib/generators/active_matrix/install/templates/matrix_agent.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-class MatrixAgent < ApplicationRecord
-  # Associations
-  has_many :agent_memories, dependent: :destroy
-  has_many :conversation_contexts, 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!
-    increment!(:messages_handled)
-  end
-
-  def update_activity!
-    update(last_active_at: Time.current)
-  end
-
-  # Password handling
-  attr_accessor :password
-
-  def authenticate(password)
-    return false unless encrypted_password.present?
-
-    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