activematrix 0.0.0 → 0.0.2

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/bot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  # Namespace module for Bot framework
+  module Bot
+  end
+end

data/lib/{matrix_sdk → active_matrix}/client.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
 
-require 'matrix_sdk'
-require 'matrix_sdk/util/events'
-
 require 'English'
 require 'forwardable'
 
-module MatrixSdk
+module ActiveMatrix
   class Client
-    extend MatrixSdk::Extensions
-    include MatrixSdk::Logging
+    extend ActiveMatrix::Extensions
+    include ActiveMatrix::Logging
     extend Forwardable
 
     # @!attribute api [r] The underlying API connection
@@ -44,11 +41,11 @@ module MatrixSdk
     # @see Api.new_for_domain
     # @see #initialize
     def self.new_for_domain(domain, **params)
-      api = MatrixSdk::Api.new_for_domain(domain, keep_wellknown: true)
+      api = ActiveMatrix::Api.new_for_domain(domain, keep_wellknown: true)
       return new(api, **params) unless api.well_known&.key?('m.identity_server')
 
-      identity_server = MatrixSdk::Api.new(api.well_known['m.identity_server']['base_url'], protocols: %i[IS])
-      new(api, **params.merge(identity_server: identity_server))
+      identity_server = ActiveMatrix::Api.new(api.well_known['m.identity_server']['base_url'], protocols: %i[IS])
+      new(api, **params, identity_server: identity_server)
     end
 
     # @param hs_url [String,URI,Api] The URL to the Matrix homeserver, without the /_matrix/ part, or an existing Api instance
@@ -56,7 +53,7 @@ module MatrixSdk
     # @param params [Hash] Additional parameters on creation
     # @option params [String,MXID] :user_id The user ID of the logged-in user
     # @option params [Integer] :sync_filter_limit (20) Limit of timeline entries in syncs
-    # @see MatrixSdk::Api.new for additional usable params
+    # @see ActiveMatrix::Api.new for additional usable params
     def initialize(hs_url, client_cache: :all, **params)
       event_initialize
 
@@ -153,7 +150,7 @@ module MatrixSdk
 
         break if data[:next_batch].nil?
 
-        since = data.next_batch
+        since = data[:next_batch]
       end
 
       rooms
@@ -168,9 +165,9 @@ module MatrixSdk
 
     # Retrieve an account data helper
     def account_data
-      return MatrixSdk::Util::AccountDataCache.new self if cache == :none
+      return ActiveMatrix::Util::AccountDataCache.new self if cache == :none
 
-      @account_data ||= MatrixSdk::Util::AccountDataCache.new self
+      @account_data ||= ActiveMatrix::Util::AccountDataCache.new self
     end
 
     # Gets a direct message room for the given user if one exists
@@ -178,7 +175,7 @@ module MatrixSdk
     # @note Will return the oldest room if multiple exist
     # @return [Room,nil] A direct message room if one exists
     def direct_room(mxid)
-      mxid = MatrixSdk::MXID.new mxid.to_s unless mxid.is_a? MatrixSdk::MXID
+      mxid = ActiveMatrix::MXID.new mxid.to_s unless mxid.is_a? ActiveMatrix::MXID
       raise ArgumentError, 'Must be a valid user ID' unless mxid.user?
 
       room_id = direct_rooms[mxid.to_s]&.first
@@ -365,7 +362,7 @@ module MatrixSdk
           end
 
           def inspect
-            "#<MatrixSdk::Response 3pid=#{to_s.inspect} added_at=\"#{added_at}\"#{validated? ? " validated_at=\"#{validated_at}\"" : ''}>"
+            "#<ActiveMatrix::Response 3pid=#{to_s.inspect} added_at=\"#{added_at}\"#{" validated_at=\"#{validated_at}\"" if validated?}>"
           end
         end
       end
@@ -376,13 +373,13 @@ module MatrixSdk
     #
     # @example Creating a room with an alias
     #   client.create_room('myroom')
-    #   #<MatrixSdk::Room ... >
+    #   #<ActiveMatrix::Room ... >
     #
     # @param room_alias [String] A default alias to set on the room, should only be the localpart
     # @return [Room] The resulting room
     # @see Protocols::CS#create_room
     def create_room(room_alias = nil, **params)
-      data = api.create_room(**params.merge(room_alias: room_alias))
+      data = api.create_room(**params, room_alias: room_alias)
       ensure_room(data.room_id)
     end
 
@@ -542,7 +539,7 @@ module MatrixSdk
       attempts = 0
       data = loop do
         break api.sync(**extra_params)
-      rescue MatrixSdk::MatrixTimeoutError => e
+      rescue ActiveMatrix::MatrixTimeoutError => e
         raise e if (attempts += 1) >= params.fetch(:allow_sync_retry, 0)
       end
 
@@ -577,7 +574,7 @@ module MatrixSdk
       orig_bad_sync_timeout = bad_sync_timeout + 0
       while @should_listen
         begin
-          sync(**params.merge(timeout: timeout))
+          sync(**params, timeout: timeout)
           return unless @should_listen
 
           bad_sync_timeout = orig_bad_sync_timeout
@@ -588,7 +585,7 @@ module MatrixSdk
           logger.warn("A #{e.class} occurred during sync")
           if e.httpstatus >= 500
             logger.warn("Serverside error, retrying in #{bad_sync_timeout} seconds...")
-            sleep(bad_sync_timeout) if bad_sync_timeout.positive? # rubocop:disable Metrics/BlockNesting
+            sleep(bad_sync_timeout) if bad_sync_timeout.positive?
             bad_sync_timeout = [bad_sync_timeout * 2, @bad_sync_timeout_limit].min
           end
         end
@@ -620,10 +617,9 @@ module MatrixSdk
 
     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
 
@@ -679,16 +675,7 @@ module MatrixSdk
         end
       end
 
-      unless cache == :none
-        account_data.tinycache_adapter.cleanup if instance_variable_defined?(:@account_data) && @account_data
-        @rooms.each do |_id, 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

data/lib/{matrix_sdk → active_matrix}/errors.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module MatrixSdk
-  # A generic error raised for issues in the MatrixSdk
+module ActiveMatrix
+  # A generic error raised for issues in the ActiveMatrix
   class MatrixError < StandardError
   end
 
@@ -30,9 +30,9 @@ module MatrixSdk
       @code = error[:errcode]
       @httpstatus = status
       @message = error[:error]
-      @data = error.reject { |k, _v| %i[errcode error].include? k }
+      @data = error.except(:errcode, :error)
 
-      super error[:error]
+      super(error[:error])
     end
 
     def to_s