activematrix 0.0.0 → 0.0.2

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module ActiveMatrix
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates ActiveMatrix migrations and initializers'
+
+      def create_migrations
+        migration_template 'create_matrix_agents.rb', 'db/migrate/create_matrix_agents.rb'
+        migration_template 'create_agent_memories.rb', 'db/migrate/create_agent_memories.rb'
+        migration_template 'create_conversation_contexts.rb', 'db/migrate/create_conversation_contexts.rb'
+        migration_template 'create_global_memories.rb', 'db/migrate/create_global_memories.rb'
+      end
+
+      def create_initializer
+        template 'active_matrix.rb', 'config/initializers/active_matrix.rb'
+      end
+
+      def create_models
+        template 'matrix_agent.rb', 'app/models/matrix_agent.rb'
+        template 'agent_memory.rb', 'app/models/agent_memory.rb'
+        template 'conversation_context.rb', 'app/models/conversation_context.rb'
+        template 'global_memory.rb', 'app/models/global_memory.rb'
+      end
+
+      def display_post_install
+        readme 'README' if behavior == :invoke
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/active_matrix/install/templates/README

@@ -0,0 +1,30 @@
+===============================================================================
+
+ActiveMatrix Multi-Agent System has been installed!
+
+Next steps:
+
+1. Run migrations:
+   rails db:migrate
+
+2. Create your first bot:
+   rails generate active_matrix:bot MyFirstBot
+
+3. Configure your agents in the Rails console:
+   agent = MatrixAgent.create!(
+     name: 'captain',
+     homeserver: 'https://matrix.org',
+     username: 'captain_bot',
+     password: 'secure_password',
+     bot_class: 'MyFirstBot'
+   )
+
+4. Start the agent system:
+   ActiveMatrix::AgentManager.instance.start_all
+
+Or start individual agents:
+   ActiveMatrix::AgentManager.instance.start_agent(agent)
+
+For more information, visit: https://github.com/seuros/agent_smith
+
+===============================================================================

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# ActiveMatrix configuration
+ActiveMatrix.configure do |config|
+  # Agent configuration
+  config.agent_startup_delay = 2.seconds # Delay between starting each agent
+  config.max_agents_per_process = 10     # Maximum agents in a single process
+  config.agent_health_check_interval = 30.seconds
+
+  # Memory configuration
+  config.conversation_history_limit = 20
+  config.conversation_stale_after = 1.day
+  config.memory_cleanup_interval = 1.hour
+
+  # Event routing configuration
+  config.event_queue_size = 1000
+  config.event_processing_timeout = 30.seconds
+
+  # Client pool configuration
+  config.max_clients_per_homeserver = 5
+  config.client_idle_timeout = 5.minutes
+
+  # Logging
+  config.agent_log_level = :info
+  config.log_agent_events = Rails.env.development?
+end
+
+# Start agent manager on Rails boot (can be disabled in environments)
+if Rails.env.production? || ENV['START_AGENTS'].present?
+  Rails.application.config.after_initialize do
+    ActiveMatrix::AgentManager.instance.start_all
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class AgentMemory < ApplicationRecord
+  belongs_to :matrix_agent
+
+  validates :key, presence: true, uniqueness: { scope: :matrix_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 unless expires_at.present?
+
+    remaining = expires_at - Time.current
+    [remaining, 0].max
+  end
+
+  # Cache integration
+  def cache_key
+    "agent_memory/#{matrix_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
+    AgentMemoryCleanupJob.set(wait_until: expires_at).perform_later if defined?(AgentMemoryCleanupJob)
+  end
+end

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

@@ -0,0 +1,72 @@
+# 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/create_agent_memories.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateAgentMemories < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :agent_memories do |t|
+      t.references :matrix_agent, null: false, foreign_key: true
+      t.string :key, null: false
+      t.jsonb :value, default: {}
+      t.datetime :expires_at
+      
+      t.timestamps
+      
+      t.index [:matrix_agent_id, :key], unique: true
+      t.index :expires_at
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class CreateConversationContexts < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :conversation_contexts do |t|
+      t.references :matrix_agent, null: false, foreign_key: true
+      t.string :user_id, null: false
+      t.string :room_id, null: false
+      t.jsonb :context, default: {}
+      t.jsonb :message_history, default: { messages: [] }
+      t.datetime :last_message_at
+      t.integer :message_count, default: 0
+      
+      t.timestamps
+      
+      t.index [:matrix_agent_id, :user_id, :room_id], unique: true, name: 'idx_conv_context_unique'
+      t.index :last_message_at
+      t.index :room_id
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateGlobalMemories < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :global_memories do |t|
+      t.string :key, null: false
+      t.jsonb :value, default: {}
+      t.string :category
+      t.datetime :expires_at
+      t.boolean :public_read, default: true
+      t.boolean :public_write, default: false
+      
+      t.timestamps
+      
+      t.index :key, unique: true
+      t.index :category
+      t.index :expires_at
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class CreateMatrixAgents < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :matrix_agents do |t|
+      t.string :name, null: false
+      t.string :homeserver, null: false
+      t.string :username, null: false
+      t.string :encrypted_password
+      t.string :access_token
+      t.string :state, default: 'offline', null: false
+      t.string :bot_class, null: false
+      t.jsonb :settings, default: {}
+      t.string :last_sync_token
+      t.datetime :last_active_at
+      t.integer :rooms_count, default: 0
+      t.integer :messages_handled, default: 0
+      
+      t.timestamps
+      
+      t.index :name, unique: true
+      t.index :state
+      t.index [:homeserver, :username]
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# 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

@@ -0,0 +1,127 @@
+# 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