activematrix 0.0.0 → 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/{matrix_sdk → active_matrix}/mxid.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MatrixSdk
+module ActiveMatrix
   class MXID
     attr_accessor :sigil, :localpart, :domain, :port
 
@@ -82,7 +82,7 @@ module MatrixSdk
     # Check if the ID is of a room
     # @return [Boolean] if the ID is of the room_id or room_alias types
     def room?
-      type == :room_id || type == :room_alias
+      %i[room_id room_alias].include?(type)
     end
 
     # Check if the ID is of a event

data/lib/{matrix_sdk → active_matrix}/protocols/as.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MatrixSdk::Protocols::AS
+module ActiveMatrix::Protocols::AS
   def self.included(_klass)
     # XXX
   end

data/lib/{matrix_sdk → active_matrix}/protocols/cs.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # rubocop:disable Metrics/ModuleLength
-module MatrixSdk::Protocols::CS
+module ActiveMatrix::Protocols::CS
   # Gets the available client API versions
   # @return [Array]
   #
@@ -12,7 +12,7 @@ module MatrixSdk::Protocols::CS
   #   # => 'latest'
   def client_api_versions
     (@client_api_versions ||= request(:get, :client, '/versions')).versions.tap do |vers|
-      vers.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
+      vers.instance_eval <<-CODE, __FILE__, __LINE__ + 1
         if !respond_to? :latest
           def latest
             last
@@ -32,7 +32,7 @@ module MatrixSdk::Protocols::CS
   #   # => true
   def client_api_unstable_features
     (@client_api_versions ||= request(:get, :client, '/versions')).unstable_features.tap do |vers|
-      vers.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
+      vers.instance_eval <<-CODE, __FILE__, __LINE__ + 1
         def has?(feature)
           feature = feature.to_s.to_sym unless feature.is_a? Symbol
           fetch(feature, nil)
@@ -68,9 +68,7 @@ module MatrixSdk::Protocols::CS
   # @see https://matrix.org/docs/spec/client_server/latest.html#get-matrix-client-r0-sync
   #      For more information on the parameters and what they mean
   def sync(timeout: 30.0, **params)
-    query = params.select do |k, _v|
-      %i[since filter full_state set_presence].include? k
-    end
+    query = params.slice(:since, :filter, :full_state, :set_presence)
 
     query[:timeout] = (timeout * 1000).to_i if timeout
     query[:timeout] = params.delete(:timeout_ms).to_i if params.key? :timeout_ms
@@ -198,7 +196,7 @@ module MatrixSdk::Protocols::CS
 
     data = {
       type: login_type,
-      initial_device_display_name: params.delete(:initial_device_display_name) { MatrixSdk::Api::USER_AGENT }
+      initial_device_display_name: params.delete(:initial_device_display_name) { ActiveMatrix::Api::USER_AGENT }
     }.merge params
     data[:device_id] = device_id if device_id
 
@@ -785,7 +783,7 @@ module MatrixSdk::Protocols::CS
     state_type = ERB::Util.url_encode state_type.to_s
     key = ERB::Util.url_encode key.to_s
 
-    request(:get, client_api_latest, "/rooms/#{room_id}/state/#{state_type}#{key.empty? ? nil : "/#{key}"}", query: query)
+    request(:get, client_api_latest, "/rooms/#{room_id}/state/#{state_type}#{"/#{key}" unless key.empty?}", query: query)
   end
 
   # Retrieves all current state objects from a room

data/lib/{matrix_sdk → active_matrix}/protocols/is.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MatrixSdk::Protocols::IS
+module ActiveMatrix::Protocols::IS
   def identity_status
     request(:get, :identity_api_v1, '/')
   end

data/lib/{matrix_sdk → active_matrix}/protocols/msc.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Preliminary support for unmerged MSCs (Matrix Spec Changes)
-module MatrixSdk::Protocols::MSC
+module ActiveMatrix::Protocols::MSC
   def refresh_mscs
     @msc = {}
   end
@@ -9,12 +9,12 @@ module MatrixSdk::Protocols::MSC
   # Check if there's support for MSC2108 - Sync over Server Sent Events
   def msc2108?
     @msc ||= {}
-    @msc[2108] ||= \
+    @msc[2108] ||=
       begin
         request(:get, :client_r0, '/sync/sse', skip_auth: true, headers: { accept: 'text/event-stream' })
-      rescue MatrixSdk::MatrixNotAuthorizedError # Returns 401 if implemented
+      rescue ActiveMatrix::MatrixNotAuthorizedError # Returns 401 if implemented
         true
-      rescue MatrixSdk::MatrixRequestError
+      rescue ActiveMatrix::MatrixRequestError
         false
       end
   rescue StandardError => e
@@ -41,9 +41,7 @@ module MatrixSdk::Protocols::MSC
       unless on_data.is_a?(Proc) && on_data.arity == 2
     raise 'Needs to be logged in' unless access_token # TODO: Better error
 
-    query = params.select do |k, _v|
-      %i[filter full_state set_presence].include? k
-    end
+    query = params.slice(:filter, :full_state, :set_presence)
     query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)
 
     req = Net::HTTP::Get.new(homeserver.dup.tap do |u|
@@ -125,7 +123,7 @@ module MatrixSdk::Protocols::MSC
 
             if %w[sync sync_error].include? event
               data = JSON.parse(data, symbolize_names: true)
-              yield((MatrixSdk::Response.new self, data), event: event, id: id)
+              yield((ActiveMatrix::Response.new self, data), event: event, id: id)
             elsif event
               logger.info "MSC2108 : #{stream_id} : Received unknown event '#{event}'; #{data}"
             end

data/lib/{matrix_sdk → active_matrix}/protocols/ss.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module MatrixSdk::Protocols::SS
+module ActiveMatrix::Protocols::SS
   # Gets the server version
   def server_version
-    MatrixSdk::Response.new(self, request(:get, :federation_v1, '/version').server).tap do |resp|
+    ActiveMatrix::Response.new(self, request(:get, :federation_v1, '/version').server).tap do |resp|
       resp.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
         def to_s
           "#{name} #{version}"

data/lib/active_matrix/railtie.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module ActiveMatrix
+  class Railtie < Rails::Railtie
+    initializer 'activematrix.configure_rails_initialization' do
+      # Configure Rails.logger as the default logger
+      ActiveMatrix.logger = Rails.logger
+    end
+
+    initializer 'activematrix.configure_cache' do
+      # Rails cache adapter is automatically used when Rails is detected
+      require 'active_matrix/util/rails_cache_adapter'
+      ActiveMatrix::Util::Tinycache.adapter = ActiveMatrix::Util::RailsCacheAdapter
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MatrixSdk
+module ActiveMatrix
   # An usability wrapper for API responses as an extended [Hash]
   # All results can be read as both hash keys and as read-only methods on the key
   #
@@ -39,7 +39,7 @@ module MatrixSdk
       data.instance_variable_set(:@api, api)
 
       data.select { |_k, v| v.is_a? Hash }
-          .each { |_v, v| Response.new api, v }
+          .each_value { |v| Response.new api, v }
 
       data
     end