activematrix 0.0.1 → 0.0.2

data/lib/active_matrix/agent_registry.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'concurrent'
+
+module ActiveMatrix
+  # Thread-safe registry for managing running bot agents
+  class AgentRegistry
+    include Singleton
+    include ActiveMatrix::Logging
+
+    def initialize
+      @agents = Concurrent::Hash.new
+      @mutex = Mutex.new
+    end
+
+    # Register a running agent
+    def register(agent_record, bot_instance)
+      @mutex.synchronize do
+        raise AgentAlreadyRunningError, "Agent #{agent_record.name} is already running" if @agents.key?(agent_record.id)
+
+        @agents[agent_record.id] = {
+          record: agent_record,
+          instance: bot_instance,
+          thread: Thread.current,
+          started_at: Time.current
+        }
+
+        logger.info "Registered agent: #{agent_record.name} (#{agent_record.id})"
+      end
+    end
+
+    # Unregister an agent
+    def unregister(agent_record)
+      @mutex.synchronize do
+        entry = @agents.delete(agent_record.id)
+        logger.info "Unregistered agent: #{agent_record.name} (#{agent_record.id})" if entry
+        entry
+      end
+    end
+
+    # Get a running agent by ID
+    def get(agent_id)
+      @agents[agent_id]
+    end
+
+    # Get agent by name
+    def get_by_name(name)
+      @agents.values.find { |entry| entry[:record].name == name }
+    end
+
+    # Get all running agents
+    def all
+      @agents.values
+    end
+
+    # Get all agent records
+    def all_records
+      @agents.values.map { |entry| entry[:record] }
+    end
+
+    # Get all bot instances
+    def all_instances
+      @agents.values.map { |entry| entry[:instance] }
+    end
+
+    # Check if an agent is running
+    def running?(agent_record)
+      @agents.key?(agent_record.id)
+    end
+
+    # Get agents by state
+    def by_state(state)
+      @agents.values.select { |entry| entry[:record].state == state.to_s }
+    end
+
+    # Get agents by bot class
+    def by_class(bot_class)
+      class_name = bot_class.is_a?(Class) ? bot_class.name : bot_class.to_s
+      @agents.values.select { |entry| entry[:record].bot_class == class_name }
+    end
+
+    # Get agents by homeserver
+    def by_homeserver(homeserver)
+      @agents.values.select { |entry| entry[:record].homeserver == homeserver }
+    end
+
+    # Broadcast to all agents
+    def broadcast
+      all_instances.each do |instance|
+        yield instance
+      rescue StandardError => e
+        logger.error "Error broadcasting to agent: #{e.message}"
+      end
+    end
+
+    # Broadcast to specific agents
+    def broadcast_to(selector)
+      agents = case selector
+               when Symbol
+                 by_state(selector)
+               when String
+                 by_name_pattern(selector)
+               when Class
+                 by_class(selector)
+               when Proc
+                 @agents.values.select { |entry| selector.call(entry[:record]) }
+               else
+                 []
+               end
+
+      agents.each do |entry|
+        yield entry[:instance]
+      rescue StandardError => e
+        logger.error "Error broadcasting to agent #{entry[:record].name}: #{e.message}"
+      end
+    end
+
+    # Get count of running agents
+    def count
+      @agents.size
+    end
+
+    # Clear all agents (used for testing)
+    def clear!
+      @mutex.synchronize do
+        @agents.clear
+      end
+    end
+
+    # Get health status of all agents
+    def health_status
+      @agents.map do |id, entry|
+        {
+          id: id,
+          name: entry[:record].name,
+          state: entry[:record].state,
+          thread_alive: entry[:thread]&.alive?,
+          uptime: Time.current - entry[:started_at],
+          last_active: entry[:record].last_active_at
+        }
+      end
+    end
+
+    private
+
+    def by_name_pattern(pattern)
+      regex = Regexp.new(pattern, Regexp::IGNORECASE)
+      @agents.values.select { |entry| entry[:record].name =~ regex }
+    end
+  end
+
+  class AgentAlreadyRunningError < StandardError; end
+end

data/lib/active_matrix/bot/multi_instance_base.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module ActiveMatrix::Bot
+  # Base class for multi-instance bot support
+  class MultiInstanceBase < Base
+    attr_reader :agent_record
+
+    def initialize(client_or_agent, **params)
+      # Handle both client and agent record initialization
+      if client_or_agent.respond_to?(:homeserver) && !client_or_agent.respond_to?(:client) # It's a client
+        super
+        @agent_record = params[:agent_record]
+      else # It's an agent record
+        @agent_record = client_or_agent
+        super(@agent_record.client, **params)
+      end
+
+      setup_agent_context if @agent_record
+    end
+
+    # Access agent-specific memory
+    def memory
+      @memory ||= ActiveMatrix::Memory.for_agent(@agent_record)
+    end
+
+    # Access conversation memory
+    def conversation_memory(user_id = nil, room_id = nil)
+      user_id ||= event[:sender] if in_event?
+      room_id ||= event[:room_id] if in_event?
+
+      return nil unless user_id && room_id
+
+      @conversation_memories ||= {}
+      @conversation_memories["#{user_id}/#{room_id}"] ||=
+        ActiveMatrix::Memory.for_conversation(@agent_record, user_id, room_id)
+    end
+
+    # Access global memory
+    def global_memory
+      ActiveMatrix::Memory.global
+    end
+
+    # Get current conversation context
+    def conversation_context
+      conversation_memory&.context || {}
+    end
+
+    # Update conversation context
+    def update_context(data)
+      conversation_memory&.update_context(data)
+    end
+
+    # Remember something in conversation
+    def remember_in_conversation(key, &)
+      conversation_memory&.remember(key, &)
+    end
+
+    # Agent state helpers
+    def agent_name
+      @agent_record&.name || settings.bot_name
+    end
+
+    def agent_state
+      @agent_record&.state || 'unknown'
+    end
+
+    def mark_busy!
+      @agent_record&.start_processing! if @agent_record&.may_start_processing?
+    end
+
+    def mark_idle!
+      @agent_record&.finish_processing! if @agent_record&.may_finish_processing?
+    end
+
+    # Inter-agent communication
+    def broadcast_to_agents(selector, data)
+      return unless defined?(AgentRegistry)
+
+      registry = AgentRegistry.instance
+      registry.broadcast_to(selector) do |agent_bot|
+        agent_bot.receive_broadcast(data, from: self)
+      end
+    end
+
+    def send_to_agent(agent_name, data)
+      return unless defined?(AgentRegistry)
+
+      registry = AgentRegistry.instance
+      entry = registry.get_by_name(agent_name)
+
+      if entry
+        entry[:instance].receive_message(data, from: self)
+        true
+      else
+        logger.warn "Agent #{agent_name} not found or not running"
+        false
+      end
+    end
+
+    # Receive inter-agent messages (override in subclasses)
+    def receive_message(data, from:)
+      logger.debug "Received message from #{from.agent_name}: #{data.inspect}"
+    end
+
+    def receive_broadcast(data, from:)
+      logger.debug "Received broadcast from #{from.agent_name}: #{data.inspect}"
+    end
+
+    # Override event handling to track conversation
+    def _handle_message(event)
+      # Mark as busy while processing
+      mark_busy!
+
+      # Track conversation if we have an agent record
+      conversation_memory(event[:sender], event[:room_id])&.add_message(event) if @agent_record && event[:type] == 'm.room.message'
+
+      super
+    ensure
+      # Mark as idle when done
+      mark_idle!
+    end
+
+    def _handle_event(event)
+      mark_busy!
+      super
+    ensure
+      mark_idle!
+    end
+
+    # Enhanced settings with agent-specific overrides
+    def settings
+      return self.class unless @agent_record
+
+      # Merge agent-specific settings with class settings
+      @settings ||= begin
+        base_settings = self.class.settings
+        agent_settings = @agent_record.settings || {}
+
+        # Create a settings proxy that checks agent settings first
+        SettingsProxy.new(base_settings, agent_settings)
+      end
+    end
+
+    private
+
+    def setup_agent_context
+      # Set up agent-specific logging
+      if @agent_record
+        @logger = ActiveMatrix.logger.dup
+        @logger.progname = "[#{@agent_record.name}]"
+      end
+
+      # Load any agent-specific configuration
+      return unless @agent_record.settings['commands_disabled']
+
+      @agent_record.settings['commands_disabled'].each do |cmd|
+        # Temporarily disable commands for this instance
+        @disabled_commands ||= []
+        @disabled_commands << cmd
+      end
+    end
+
+    # Settings proxy to merge class and instance settings
+    class SettingsProxy
+      def initialize(base_settings, agent_settings)
+        @base_settings = base_settings
+        @agent_settings = agent_settings
+      end
+
+      def method_missing(method, *, &)
+        method_name = method.to_s.gsub(/\?$/, '')
+
+        # Check agent settings first
+        if @agent_settings.key?(method_name)
+          value = @agent_settings[method_name]
+          return method.to_s.end_with?('?') ? !value.nil? : value
+        end
+
+        # Fall back to base settings
+        @base_settings.send(method, *, &)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        method_name = method.to_s.gsub(/\?$/, '')
+        @agent_settings.key?(method_name) || @base_settings.respond_to?(method, include_private)
+      end
+    end
+  end
+end

data/lib/active_matrix/client.rb

@@ -150,7 +150,7 @@ module ActiveMatrix
 
         break if data[:next_batch].nil?
 
-        since = data.next_batch
+        since = data[:next_batch]
       end
 
       rooms
@@ -617,10 +617,9 @@ module ActiveMatrix
 
     def handle_sync_response(data)
       data.dig(:account_data, :events)&.each do |account_data|
-        if cache != :none
-          adapter = self.account_data.tinycache_adapter
-          adapter.write(account_data[:type], account_data[:content], expires_in: self.account_data.cache_time)
-        end
+        # Store the account data in cache
+        self.account_data.write(account_data[:type], account_data[:content]) if account_data[:type]
+
         fire_account_data(MatrixEvent.new(self, account_data))
       end
 
@@ -676,16 +675,7 @@ module ActiveMatrix
         end
       end
 
-      unless cache == :none
-        account_data.tinycache_adapter.cleanup if instance_variable_defined?(:@account_data) && @account_data
-        @rooms.each_value do |room|
-          # Clean up old cache data after every sync
-          # TODO Run this in a thread?
-          room.tinycache_adapter.cleanup
-          room.account_data.tinycache_adapter.cleanup
-          room.room_state.tinycache_adapter.cleanup
-        end
-      end
+      # Rails.cache handles its own cleanup/expiration
 
       nil
     end

data/lib/active_matrix/client_pool.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'concurrent'
+
+module ActiveMatrix
+  # Manages a pool of Matrix client connections for efficiency
+  class ClientPool
+    include Singleton
+    include ActiveMatrix::Logging
+
+    def initialize
+      @pools = Concurrent::Hash.new
+      @config = ActiveMatrix.config
+      @mutex = Mutex.new
+    end
+
+    # Get or create a client for a homeserver
+    def get_client(homeserver, **)
+      @mutex.synchronize do
+        pool = get_or_create_pool(homeserver)
+        pool.checkout(**)
+      end
+    end
+
+    # Return a client to the pool
+    def checkin(client)
+      homeserver = client.homeserver
+      pool = @pools[homeserver]
+      pool&.checkin(client)
+    end
+
+    # Get pool statistics
+    def stats
+      @pools.map do |homeserver, pool|
+        {
+          homeserver: homeserver,
+          size: pool.size,
+          available: pool.available_count,
+          in_use: pool.in_use_count
+        }
+      end
+    end
+
+    # Clear all pools
+    def clear!
+      @mutex.synchronize do
+        @pools.each_value(&:clear!)
+        @pools.clear
+      end
+    end
+
+    # Shutdown all pools
+    def shutdown
+      clear!
+    end
+
+    private
+
+    def get_or_create_pool(homeserver)
+      @pools[homeserver] ||= HomeserverPool.new(
+        homeserver,
+        max_size: @config&.max_clients_per_homeserver || 5,
+        timeout: @config&.client_idle_timeout || 5.minutes
+      )
+    end
+
+    # Pool for a specific homeserver
+    class HomeserverPool
+      include ActiveMatrix::Logging
+
+      attr_reader :homeserver, :max_size, :timeout
+
+      def initialize(homeserver, max_size:, timeout:)
+        @homeserver = homeserver
+        @max_size = max_size
+        @timeout = timeout
+        @available = []
+        @in_use = {}
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+      end
+
+      def checkout(**)
+        @mutex.synchronize do
+          # Try to find an available client
+          client = find_available_client
+
+          # Create new client if needed and pool not full
+          client = create_client(**) if client.nil? && @in_use.size < @max_size
+
+          # Wait for a client if pool is full
+          while client.nil?
+            @condition.wait(@mutex, 1)
+            client = find_available_client
+          end
+
+          # Mark as in use
+          @available.delete(client)
+          @in_use[client.object_id] = {
+            client: client,
+            checked_out_at: Time.current
+          }
+
+          client
+        end
+      end
+
+      def checkin(client)
+        @mutex.synchronize do
+          entry = @in_use.delete(client.object_id)
+          return unless entry
+
+          # Add back to available pool if still valid
+          if client_valid?(client)
+            @available << client
+          else
+            # Client is no longer valid, don't return to pool
+            logger.debug "Discarding invalid client for #{@homeserver}"
+          end
+
+          # Signal waiting threads
+          @condition.signal
+        end
+      end
+
+      def size
+        @mutex.synchronize { @available.size + @in_use.size }
+      end
+
+      def available_count
+        @mutex.synchronize { @available.size }
+      end
+
+      def in_use_count
+        @mutex.synchronize { @in_use.size }
+      end
+
+      def clear!
+        @mutex.synchronize do
+          # Stop all clients
+          (@available + @in_use.values.map { |e| e[:client] }).each do |client|
+            client.stop_listener_thread if client.listening?
+            client.logout if client.logged_in?
+          rescue StandardError => e
+            logger.error "Error cleaning up client: #{e.message}"
+          end
+
+          @available.clear
+          @in_use.clear
+        end
+      end
+
+      private
+
+      def find_available_client
+        # Remove any expired clients
+        @available.select! { |client| client_valid?(client) }
+
+        # Return first available
+        @available.first
+      end
+
+      def create_client(**)
+        logger.debug "Creating new client for #{@homeserver}"
+
+        ActiveMatrix::Client.new(
+          @homeserver,
+          client_cache: :some,
+          sync_filter_limit: 20,
+          **
+        )
+      end
+
+      def client_valid?(client)
+        # Check if client is still connected and responsive
+        return false unless client
+
+        # Could add more validation here
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+
+  # Monkey patch Client to support pooling
+  class Client
+    # Checkin this client back to the pool
+    def checkin_to_pool
+      ClientPool.instance.checkin(self) if defined?(ClientPool)
+    end
+  end
+end