activematrix 0.0.1 → 0.0.2

data/lib/active_matrix/memory/global_memory.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module ActiveMatrix
+  module Memory
+    # Global memory storage accessible to all agents
+    class GlobalMemory < Base
+      include Singleton
+
+      # Get a value from global memory
+      def get(key)
+        fetch_with_cache(key) do
+          return nil unless defined?(::GlobalMemory)
+
+          ::GlobalMemory.get(key)
+        end
+      end
+
+      # Set a value in global memory
+      def set(key, value, category: nil, expires_in: nil, public_read: true, public_write: false)
+        return false unless defined?(::GlobalMemory)
+
+        write_through(key, value, expires_in: expires_in) do
+          ::GlobalMemory.set(key, value,
+                             category: category,
+                             expires_in: expires_in,
+                             public_read: public_read,
+                             public_write: public_write)
+        end
+      end
+
+      # Check if a key exists
+      def exists?(key)
+        return false unless defined?(::GlobalMemory)
+
+        if @cache_enabled && Rails.cache.exist?(cache_key(key))
+          true
+        else
+          ::GlobalMemory.active.exists?(key: key)
+        end
+      end
+
+      # Delete a key
+      def delete(key)
+        return false unless defined?(::GlobalMemory)
+
+        delete_through(key) do
+          ::GlobalMemory.where(key: key).destroy_all.any?
+        end
+      end
+
+      # Get all keys in a category
+      def keys(category: nil)
+        return [] unless defined?(::GlobalMemory)
+
+        scope = ::GlobalMemory.active
+        scope = scope.by_category(category) if category
+        scope.pluck(:key)
+      end
+
+      # Get all values in a category
+      def by_category(category)
+        return {} unless defined?(::GlobalMemory)
+
+        ::GlobalMemory.active.by_category(category).pluck(:key, :value).to_h
+      end
+
+      # Check if readable by agent
+      def readable?(key, agent = nil)
+        return false unless defined?(::GlobalMemory)
+
+        memory = ::GlobalMemory.find_by(key: key)
+        memory&.readable_by?(agent)
+      end
+
+      # Check if writable by agent
+      def writable?(key, agent = nil)
+        return false unless defined?(::GlobalMemory)
+
+        memory = ::GlobalMemory.find_by(key: key)
+        memory&.writable_by?(agent)
+      end
+
+      # Get with permission check
+      def get_for_agent(key, agent)
+        return nil unless readable?(key, agent)
+
+        get(key)
+      end
+
+      # Set with permission check
+      def set_for_agent(key, value, agent, **)
+        # Allow creating new keys or updating writable ones
+        memory = ::GlobalMemory.find_by(key: key)
+        return false if memory && !memory.writable_by?(agent)
+
+        set(key, value, **)
+      end
+
+      # Remember something globally
+      def remember(key, **)
+        value = get(key)
+        return value if value.present?
+
+        value = yield
+        set(key, value, **) if value.present?
+        value
+      end
+
+      # Broadcast a value to all agents
+      def broadcast(key, value, expires_in: 5.minutes)
+        set(key, value, category: 'broadcast', expires_in: expires_in, public_read: true)
+
+        # Notify all agents if event router is available
+        if defined?(EventRouter)
+          EventRouter.instance.broadcast_event({
+                                                 type: 'global_memory.broadcast',
+                                                 key: key,
+                                                 value: value
+                                               })
+        end
+
+        true
+      end
+
+      # Share data between specific agents
+      def share(key, value, agent_names, expires_in: nil)
+        set(key, {
+              value: value,
+              allowed_agents: agent_names
+            }, category: 'shared', expires_in: expires_in, public_read: false)
+      end
+
+      # Get shared data if allowed
+      def get_shared(key, agent)
+        data = get(key)
+        return nil unless data.is_a?(Hash) && data['allowed_agents']
+
+        allowed = data['allowed_agents']
+        return unless allowed.include?(agent.name) || allowed.include?('*')
+
+        data['value']
+      end
+
+      protected
+
+      def cache_key(key)
+        "global/#{key}"
+      end
+    end
+  end
+end

data/lib/active_matrix/memory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  # Memory system for multi-agent architecture
+  module Memory
+    autoload :AgentMemory, 'active_matrix/memory/agent_memory'
+    autoload :ConversationMemory, 'active_matrix/memory/conversation_memory'
+    autoload :GlobalMemory, 'active_matrix/memory/global_memory'
+    autoload :Base, 'active_matrix/memory/base'
+
+    class << self
+      # Get memory interface for an agent
+      def for_agent(agent)
+        AgentMemory.new(agent)
+      end
+
+      # Get conversation memory for agent and user
+      def for_conversation(agent, user_id, room_id)
+        ConversationMemory.new(agent, user_id, room_id)
+      end
+
+      # Access global memory
+      def global
+        GlobalMemory.instance
+      end
+    end
+  end
+end

data/lib/active_matrix/room.rb

@@ -4,8 +4,8 @@ module ActiveMatrix
   # A class for tracking the information about a room on Matrix
   class Room
     extend ActiveMatrix::Extensions
-    extend ActiveMatrix::Util::Tinycache
     include ActiveMatrix::Logging
+    include ActiveMatrix::Util::Cacheable
 
     # @!attribute [rw] event_history_limit
     #   @return [Fixnum] the limit of events to keep in the event log
@@ -24,17 +24,9 @@ module ActiveMatrix
     #   An inspect method that skips a handful of instance variables to avoid
     #   flooding the terminal with debug data.
     #   @return [String] a regular inspect string without the data for some variables
-    ignore_inspect :client, :events, :prev_batch, :logger, :tinycache_adapter
-
-    # Requires heavy lookups, so they're cached for an hour
-    cached :joined_members, cache_level: :all, expires_in: 60 * 60
-
-    # Only cache unfiltered requests for aliases and members
-    cached :aliases, unless: proc { |_, args| args.any? }, cache_level: :all, expires_in: 60 * 60
-    cached :all_members, unless: proc { |_, args| args.any? }, cache_level: :all, expires_in: 60 * 60
+    ignore_inspect :client, :events, :prev_batch, :logger
 
     alias room_id id
-    alias members joined_members
 
     # Create a new room instance
     #
@@ -74,23 +66,22 @@ module ActiveMatrix
       @events = []
       @event_history_limit = 10
       @room_type = nil
+      @pre_populated_members = nil # For pre-populated members from tests
+      @cached_joined_members = nil # Instance cache for joined members
+      @cached_all_members = nil    # Instance cache for all members
 
       @prev_batch = nil
 
       %i[name topic canonical_alias avatar_url].each do |type|
-        room_state.tinycache_adapter.write("m.room.#{type}", { type => data.delete(type) }) if data.key? type
+        room_state.write("m.room.#{type}", { type => data.delete(type) }) if data.key? type
       end
-      room_state.tinycache_adapter.write('m.room.join_rules', { join_rule: data.delete(:join_rule) }) if data.key? :join_rule
-      room_state.tinycache_adapter.write('m.room.history_visibility', { history_visibility: data.delete(:world_readable) ? :world_readable : nil }) if data.key? :world_readable
+      room_state.write('m.room.join_rules', { join_rule: data.delete(:join_rule) }) if data.key? :join_rule
+      room_state.write('m.room.history_visibility', { history_visibility: data.delete(:world_readable) ? :world_readable : nil }) if data.key? :world_readable
 
       data.each do |k, v|
         next if %i[client].include? k
 
-        if respond_to?(:"#{k}_cached?") && send(:"#{k}_cached?")
-          tinycache_adapter.write(k, v)
-        elsif instance_variable_defined? "@#{k}"
-          instance_variable_set("@#{k}", v)
-        end
+        instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
       end
 
       @id = room_id.to_s
@@ -182,6 +173,36 @@ module ActiveMatrix
     #
     # @return [Array(User)] The list of members in the room
     def joined_members
+      # Return pre-populated members if they exist (for testing)
+      return @pre_populated_members if @pre_populated_members
+
+      # Return cached instance if available
+      return @cached_joined_members if @cached_joined_members
+
+      return fetch_joined_members unless cache_available?
+
+      # Cache the raw data that can be used to reconstruct User objects
+      members_data = cache.fetch(cache_key(:joined_members), expires_in: 1.hour) do
+        # Convert API response to cacheable format
+        api_response = client.api.get_room_joined_members(id)[:joined]
+        api_response.map do |mxid, data|
+          {
+            mxid: mxid.to_s,
+            display_name: data[:display_name],
+            avatar_url: data[:avatar_url]
+          }
+        end
+      end
+
+      # Reconstruct User objects from cached data and cache at instance level
+      @cached_joined_members = members_data.map do |member|
+        User.new(client, member[:mxid],
+                 display_name: member[:display_name],
+                 avatar_url: member[:avatar_url])
+      end
+    end
+
+    def fetch_joined_members
       client.api.get_room_joined_members(id)[:joined].map do |mxid, data|
         User.new(client, mxid.to_s,
                  display_name: data.fetch(:display_name, nil),
@@ -189,6 +210,8 @@ module ActiveMatrix
       end
     end
 
+    alias members joined_members
+
     # Get all members (member events) in the room
     #
     # @note This will also count members who've knocked, been invited, have left, or have been banned.
@@ -197,6 +220,24 @@ module ActiveMatrix
     #
     # @return [Array(User)] The complete list of members in the room, regardless of membership state
     def all_members(**params)
+      # Return pre-populated members if they exist and no filtering params (for testing)
+      return @pre_populated_members if @pre_populated_members && params.empty?
+
+      # Return cached instance if available and no params
+      return @cached_all_members if @cached_all_members && params.empty?
+
+      return fetch_all_members(**params) if !params.empty? || client.cache == :none || !cache_available?
+
+      # Cache the raw member state keys, not User objects
+      members_data = cache.fetch(cache_key(:all_members), expires_in: 1.hour) do
+        client.api.get_room_members(id, **params)[:chunk].map { |ch| ch[:state_key] }
+      end
+
+      # Reconstruct User objects from cached data and cache at instance level
+      @cached_all_members = members_data.map { |state_key| client.get_user(state_key) }
+    end
+
+    def fetch_all_members(**params)
       client.api.get_room_members(id, **params)[:chunk].map { |ch| client.get_user(ch[:state_key]) }
     end
 
@@ -206,7 +247,8 @@ module ActiveMatrix
     #
     # @return [String,nil] The room name - if any
     def name
-      get_state('m.room.name')[:name]
+      state = get_state('m.room.name')
+      state&.dig(:name)
     rescue MatrixNotFoundError
       # No room name has been specified
       nil
@@ -323,8 +365,20 @@ module ActiveMatrix
     # @param canonical_only [Boolean] Should the list of aliases only contain the canonical ones
     # @return [Array[String]] The assigned room aliases
     def aliases(canonical_only: true)
+      return fetch_aliases(canonical_only: canonical_only) if !canonical_only || client.cache == :none || !cache_available?
+
+      cache.fetch(cache_key(:aliases), expires_in: 1.hour) do
+        fetch_aliases(canonical_only: true)
+      end
+    end
+
+    def fetch_aliases(canonical_only: true)
       canonical = get_state('m.room.canonical_alias') rescue {}
-      aliases = ([canonical[:alias]].compact + (canonical[:alt_aliases] || [])).uniq.sort
+      # Handle both hash-like and Response objects
+      alias_value = canonical.respond_to?(:alias) ? canonical.alias : canonical[:alias]
+      alt_aliases = canonical.respond_to?(:alt_aliases) ? canonical.alt_aliases : canonical[:alt_aliases]
+
+      aliases = ([alias_value].compact + (alt_aliases || [])).uniq.sort
       return aliases if canonical_only
 
       (aliases + client.api.get_room_aliases(id).aliases).uniq.sort
@@ -735,7 +789,8 @@ module ActiveMatrix
     # @return [Boolean] if the addition was successful or not
     def add_alias(room_alias)
       client.api.set_room_alias(id, room_alias)
-      tinycache_adapter.read(:aliases) << room_alias if tinycache_adapter.exist?(:aliases)
+      # Clear the cache to force refresh
+      cache.delete(cache_key(:aliases)) if cache_available?
       true
     end
 
@@ -746,7 +801,7 @@ module ActiveMatrix
     #       alias list updates.
     def reload_aliases!
       room_state.expire('m.room.canonical_alias')
-      clear_aliases_cache
+      cache.delete(cache_key(:aliases)) if cache_available?
     end
     alias refresh_aliases! reload_aliases!
 
@@ -896,7 +951,7 @@ module ActiveMatrix
     def modify_user_power_levels(users = nil, users_default = nil)
       return false if users.nil? && users_default.nil?
 
-      room_state.tinycache_adapter.expire 'm.room.power_levels'
+      room_state.expire 'm.room.power_levels'
 
       data = power_levels
       data[:users_default] = users_default unless users_default.nil?
@@ -928,7 +983,7 @@ module ActiveMatrix
     def modify_required_power_levels(events = nil, params = {})
       return false if events.nil? && (params.nil? || params.empty?)
 
-      room_state.tinycache_adapter.expire 'm.room.power_levels'
+      room_state.expire 'm.room.power_levels'
 
       data = power_levels
       data.merge!(params)
@@ -946,38 +1001,52 @@ module ActiveMatrix
 
     private
 
+    def cache_key(method_name)
+      "activematrix:room:#{id}:#{method_name}"
+    end
+
+    def cache_available?
+      defined?(::Rails) && ::Rails.respond_to?(:cache) && ::Rails.cache
+    end
+
+    def cache
+      ::Rails.cache
+    end
+
     def ensure_member(member)
       return unless client.cache == :all
 
-      tinycache_adapter.write(:joined_members, []) unless tinycache_adapter.exist? :joined_members
-
-      members = tinycache_adapter.read(:joined_members) || []
-      members << member unless members.any? { |m| m.id == member.id }
+      # Add member to pre-populated list
+      @pre_populated_members ||= []
+      @pre_populated_members << member unless @pre_populated_members.include?(member)
 
-      tinycache_adapter.write(:joined_members, members)
+      # Clear the cache to force a refresh on next access
+      cache.delete(cache_key(:joined_members)) if cache_available?
     end
 
     def handle_room_member(event)
       return unless client.cache == :all
 
-      if event.dig(*%i[content membership]) == 'join'
-        ensure_member(client.get_user(event[:state_key]).dup.tap do |u|
-          u.instance_variable_set(:@display_name, event.dig(*%i[content displayname]))
-        end)
-      elsif tinycache_adapter.exist? :joined_members
-        members = tinycache_adapter.read(:joined_members)
-        members.delete_if { |m| m.id == event[:state_key] }
-      end
+      # Cache the user if it's a join event
+      client.get_user(event[:state_key]) if event.dig(:content, :membership) == 'join' && event[:state_key]
+
+      # Clear pre-populated members when membership changes
+      @pre_populated_members = nil
+
+      # Clear instance caches when membership changes
+      @cached_joined_members = nil
+      @cached_all_members = nil
+
+      # Clear the cache when membership changes
+      cache.delete(cache_key(:joined_members)) if cache_available?
+      cache.delete(cache_key(:all_members)) if cache_available?
     end
 
     def handle_room_canonical_alias(event)
-      room_state.tinycache_adapter.write('m.room.canonical_alias', event[:content], expires_in: room_state.cache_time)
-      canonical_alias = event.dig(*%i[content alias])
+      room_state.write('m.room.canonical_alias', event[:content])
 
-      data = tinycache_adapter.read(:aliases) || []
-      data << canonical_alias
-      data += event.dig(*%i[content alt_aliases]) || []
-      tinycache_adapter.write(:aliases, data.uniq.sort)
+      # Clear the aliases cache
+      cache.delete(cache_key(:aliases)) if cache_available?
     end
 
     def room_handlers?
@@ -1001,10 +1070,8 @@ module ActiveMatrix
     end
 
     def put_account_data(event)
-      if client.cache != :none
-        adapter = account_data.tinycache_adapter
-        adapter.write(event[:type], event[:content], expires_in: account_data.cache_time)
-      end
+      # Store the account data in cache
+      account_data.write(event[:type], event[:content]) if event[:type]
 
       return unless room_handlers?
 
@@ -1026,15 +1093,28 @@ module ActiveMatrix
       if INTERNAL_HANDLERS.key? event[:type]
         send(INTERNAL_HANDLERS[event[:type]], event)
       elsif client.cache != :none
-        adapter = room_state.tinycache_adapter
-        key = event[:type]
-        key += "|#{event[:state_key]}" unless event[:state_key].nil? || event[:state_key].empty?
-        adapter.write(key, event[:content], expires_in: room_state.cache_time)
+        # StateEventCache will handle caching internally
+        room_state.write(event[:type], event[:content], event[:state_key])
       end
 
       return unless room_handlers?
 
       ensure_room_handlers[:state_event].fire(MatrixEvent.new(self, event), event[:type])
     end
+
+    # Define what attributes to cache
+    def cache_attributes
+      {
+        id: @id,
+        room_type: @room_type,
+        prev_batch: @prev_batch,
+        event_history_limit: @event_history_limit
+      }
+    end
+
+    # Override cache_id to use room ID
+    def cache_id
+      @id
+    end
   end
 end

data/lib/active_matrix/rooms/space.rb

@@ -26,11 +26,7 @@ module ActiveMatrix::Rooms
 
         # Inject available room information
         r.each do |k, v|
-          if room.respond_to?(:"#{k}_cached?") && send(:"#{k}_cached?")
-            room.send(:tinycache_adapter).write(k, v)
-          elsif room.instance_variable_defined? "@#{k}"
-            room.instance_variable_set("@#{k}", v)
-          end
+          room.instance_variable_set("@#{k}", v) if room.instance_variable_defined? "@#{k}"
         end
         room
       end

data/lib/active_matrix/user.rb

@@ -4,6 +4,7 @@ module ActiveMatrix
   # A class for tracking information about a user on Matrix
   class User
     extend ActiveMatrix::Extensions
+    include ActiveMatrix::Util::Cacheable
 
     attr_reader :id, :client
     alias user_id :id
@@ -157,6 +158,15 @@ module ActiveMatrix
       end
     end
 
+    # Define what attributes to cache
+    def cache_attributes
+      {
+        id: @id,
+        display_name: @display_name,
+        avatar_url: @avatar_url
+      }
+    end
+
     private
 
     def raw_presence

data/lib/active_matrix/util/account_data_cache.rb

@@ -3,20 +3,20 @@
 module ActiveMatrix::Util
   class AccountDataCache
     extend ActiveMatrix::Extensions
-    extend ActiveMatrix::Util::Tinycache
     include Enumerable
 
     attr_reader :client, :room
 
     attr_accessor :cache_time
 
-    ignore_inspect :client, :room, :tinycache_adapter
+    ignore_inspect :client, :room
 
     def initialize(client, room: nil, cache_time: 1 * 60 * 60, **_params)
       raise ArgumentError, 'Must be given a Client instance' unless client.is_a? ActiveMatrix::Client
 
       @client = client
       @cache_time = cache_time
+      @tracked_keys = Set.new
 
       return unless room
 
@@ -25,15 +25,22 @@ module ActiveMatrix::Util
     end
 
     def reload!
-      tinycache_adapter.clear
+      # Clear all cache entries for this account data
+      return unless cache_available?
+
+      if room
+        cache.delete_matched("activematrix:account_data:#{client.mxid}:room:#{room.id}:*")
+      else
+        cache.delete_matched("activematrix:account_data:#{client.mxid}:global:*")
+      end
     end
 
     def keys
-      tinycache_adapter.send(:cache).keys
+      @tracked_keys.to_a.sort
     end
 
     def values
-      keys.map { |key| tinycache_adapter.read(key) }
+      []
     end
 
     def size
@@ -41,18 +48,12 @@ module ActiveMatrix::Util
     end
 
     def key?(key)
-      keys.key?(key.to_s)
+      cache_available? && cache.exist?(cache_key(key))
     end
 
     def each(live: false)
-      return to_enum(__method__, live: live) { keys.count } unless block_given?
-
-      keys.each do |key|
-        v = live ? self[key] : tinycache_adapter.read(key)
-        # hash = v.hash
-        yield key, v
-        # self[key] = v if hash != v.hash
-      end
+      to_enum(__method__, live: live) { 0 } unless block_given?
+      # Not enumerable with Rails.cache
     end
 
     def delete(key)
@@ -62,20 +63,30 @@ module ActiveMatrix::Util
       else
         client.api.set_account_data(client.mxid, key, {})
       end
-      tinycache_adapter.delete(key)
+      cache.delete(cache_key(key)) if cache_available?
     end
 
     def [](key)
       key = key.to_s unless key.is_a? String
-      tinycache_adapter.fetch(key, expires_in: @cache_time) do
-        if room
-          client.api.get_room_account_data(client.mxid, room.id, key)
-        else
-          client.api.get_account_data(client.mxid, key)
-        end
-      rescue ActiveMatrix::MatrixNotFoundError
-        {}
+
+      # Track the key whenever it's accessed
+      @tracked_keys.add(key)
+
+      return fetch_account_data(key) unless cache_available?
+
+      cache.fetch(cache_key(key), expires_in: @cache_time) do
+        fetch_account_data(key)
+      end
+    end
+
+    def fetch_account_data(key)
+      if room
+        client.api.get_room_account_data(client.mxid, room.id, key)
+      else
+        client.api.get_account_data(client.mxid, key)
       end
+    rescue ActiveMatrix::MatrixNotFoundError
+      {}
     end
 
     def []=(key, value)
@@ -85,7 +96,34 @@ module ActiveMatrix::Util
       else
         client.api.set_account_data(client.mxid, key, value)
       end
-      tinycache_adapter.write(key, value)
+
+      @tracked_keys.add(key)
+      cache.write(cache_key(key), value, expires_in: @cache_time) if cache_available?
+    end
+
+    # Write data without making API call (for sync responses)
+    def write(key, value)
+      key = key.to_s unless key.is_a? String
+      @tracked_keys.add(key)
+      cache.write(cache_key(key), value, expires_in: @cache_time) if cache_available?
+    end
+
+    private
+
+    def cache_key(key)
+      if room
+        "activematrix:account_data:#{client.mxid}:room:#{room.id}:#{key}"
+      else
+        "activematrix:account_data:#{client.mxid}:global:#{key}"
+      end
+    end
+
+    def cache_available?
+      defined?(::Rails) && ::Rails.respond_to?(:cache) && ::Rails.cache
+    end
+
+    def cache
+      ::Rails.cache
     end
   end
 end