activematrix 0.0.0 → 0.0.2

data/lib/active_matrix/util/cacheable.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  module Util
+    # Provides caching functionality for Matrix objects
+    # Handles serialization/deserialization to work with Rails.cache
+    module Cacheable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :cached_at
+      end
+
+      class_methods do
+        # Reconstruct object from cached data
+        def from_cache(client, data)
+          return nil unless data.is_a?(Hash) && data[:_cache_class] == name
+
+          # Remove cache metadata
+          attrs = data.except(:_cache_class, :_cached_at)
+
+          # Reconstruct based on class type
+          case name
+          when 'ActiveMatrix::User'
+            new(client, attrs[:id], attrs.except(:id))
+          when 'ActiveMatrix::Room'
+            new(client, attrs[:id], attrs.except(:id))
+          else
+            new(client, attrs)
+          end
+        end
+      end
+
+      # Convert object to cacheable hash
+      def to_cache
+        data = cache_attributes.merge(
+          _cache_class: self.class.name,
+          _cached_at: Time.current
+        )
+
+        # Ensure we only cache serializable data
+        data.deep_stringify_keys
+      end
+
+      # Override in each class to specify what to cache
+      def cache_attributes
+        if respond_to?(:attributes)
+          attributes
+        elsif respond_to?(:to_h)
+          to_h
+        else
+          {}
+        end
+      end
+
+      # Generate a cache key for this object
+      def cache_key(*suffixes)
+        base_key = "#{self.class.name.underscore}:#{cache_id}"
+        suffixes.any? ? "#{base_key}:#{suffixes.join(':')}" : base_key
+      end
+
+      # Override in each class if ID method is different
+      def cache_id
+        respond_to?(:id) ? id : object_id
+      end
+
+      # Check if this object was loaded from cache
+      def from_cache?
+        @cached_at.present?
+      end
+    end
+  end
+end

data/lib/{matrix_sdk → active_matrix}/util/events.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-module MatrixSdk
+module ActiveMatrix
   class EventHandlerArray < Hash
-    include MatrixSdk::Logging
+    include ActiveMatrix::Logging
     attr_accessor :reraise_exceptions
 
-    def initialize(*args)
+    def initialize(*)
       @reraise_exceptions = false
 
-      super(*args)
+      super
     end
 
     def add_handler(filter = nil, id = nil, &block)
@@ -32,7 +32,7 @@ module MatrixSdk
   end
 
   class Event
-    extend MatrixSdk::Extensions
+    extend ActiveMatrix::Extensions
 
     attr_writer :handled
 
@@ -57,7 +57,7 @@ module MatrixSdk
 
     def initialize(error, source)
       @error = error
-      super source
+      super(source)
     end
 
     def source
@@ -74,7 +74,7 @@ module MatrixSdk
     def initialize(sender, event = nil, filter = nil)
       @event = event
       @filter = filter || @event[:type]
-      super sender
+      super(sender)
     end
 
     def matches?(filter, filter_override = nil)
@@ -93,7 +93,7 @@ module MatrixSdk
     end
 
     def to_s
-      "#{event[:type]}: #{event.reject { |k, _v| k == :type }.to_json}"
+      "#{event[:type]}: #{event.except(:type).to_json}"
     end
 
     def method_missing(method, *args)

data/lib/{matrix_sdk → active_matrix}/util/extensions.rb

@@ -8,7 +8,11 @@ unless Object.respond_to? :yield_self
   end
 end
 
-module MatrixSdk
+# Time.current is provided by ActiveSupport
+
+# Time duration helpers are provided by ActiveSupport
+
+module ActiveMatrix
   module Extensions
     def events(*symbols)
       module_name = "#{name}Events"
@@ -21,7 +25,7 @@ module MatrixSdk
         name = sym.to_s
 
         initializers << "
-          @on_#{name} = MatrixSdk::EventHandlerArray.new
+          @on_#{name} = ActiveMatrix::EventHandlerArray.new
         "
         readers << ":on_#{name}"
         methods << "
@@ -69,17 +73,4 @@ module MatrixSdk
       *, __FILE__, __LINE__ - 14
     end
   end
-
-  module Logging
-    def logger
-      return MatrixSdk.logger if MatrixSdk.global_logger?
-      return @logger if instance_variable_defined?(:@logger) && @logger
-
-      ::Logging.logger[self]
-    end
-
-    def logger=(logger)
-      @logger = logger
-    end
-  end
 end

data/lib/active_matrix/util/state_event_cache.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module ActiveMatrix::Util
+  class StateEventCache
+    extend ActiveMatrix::Extensions
+    include Enumerable
+
+    attr_reader :room
+
+    attr_accessor :cache_time
+
+    ignore_inspect :client, :room
+
+    def initialize(room, cache_time: 30 * 60, **_params)
+      raise ArgumentError, 'Must be given a Room instance' unless room.is_a? ActiveMatrix::Room
+
+      @room = room
+      @cache_time = cache_time
+    end
+
+    def client
+      @room.client
+    end
+
+    def reload!
+      # Clear all cache entries for this room's state
+      cache.delete_matched("activematrix:room:#{room.id}:state:*") if cache_available?
+    end
+
+    def keys
+      # State is not enumerable when using Rails.cache
+      # This would require keeping track of keys separately
+      []
+    end
+
+    def values
+      []
+    end
+
+    def size
+      keys.count
+    end
+
+    def key?(type, key = nil)
+      cache_available? && cache.exist?(cache_key(type, key))
+    end
+
+    def expire(type, key = nil)
+      cache.delete(cache_key(type, key)) if cache_available?
+    end
+
+    def each(live: false)
+      to_enum(__method__, live: live) { 0 } unless block_given?
+      # Not enumerable with Rails.cache
+    end
+
+    def delete(type, key = nil)
+      type = type.to_s unless type.is_a? String
+      client.api.set_room_state(room.id, type, {}, **{ state_key: key }.compact)
+      cache.delete(cache_key(type, key)) if cache_available?
+    end
+
+    def [](type, key = nil)
+      type = type.to_s unless type.is_a? String
+      return fetch_state(type, key) if !cache_available? || client.cache == :none
+
+      begin
+        cached_value = cache.fetch(cache_key(type, key), expires_in: @cache_time) do
+          result = fetch_state(type, key)
+
+          # Convert Response objects to plain hashes for caching
+          # Response objects extend Hash but contain an @api instance variable that can't be serialized
+          if result.is_a?(Hash)
+            # Create a clean hash with just the data, no instance variables or extended modules
+            # Deep convert to ensure no mock objects are included
+            clean_hash = {}
+            result.each do |key, value|
+              clean_hash[key] = case value
+                                when Hash then value.to_h
+                                when Array then value.map { |v| v.is_a?(Hash) ? v.to_h : v }
+                                else value
+                                end
+            end
+            clean_hash
+          else
+            result
+          end
+        end
+
+        # If it's a hash and we have an API client, convert it back to a Response
+        if cached_value.is_a?(Hash) && !cached_value.empty? && client.respond_to?(:api)
+          ActiveMatrix::Response.new(client.api, cached_value)
+        else
+          cached_value
+        end
+      rescue StandardError
+        # If caching fails, return the direct result
+        fetch_state(type, key)
+      end
+    end
+
+    def fetch_state(type, key = nil)
+      client.api.get_room_state(room.id, type, **{ key: key }.compact)
+    rescue ActiveMatrix::MatrixNotFoundError
+      {}
+    end
+
+    def []=(type, key = nil, value) # rubocop:disable Style/OptionalArguments Not possible to put optional last
+      type = type.to_s unless type.is_a? String
+      client.api.set_room_state(room.id, type, value, **{ state_key: key }.compact)
+
+      return unless cache_available?
+
+      # Convert to plain hash for caching to avoid serialization issues with Mocha
+      cacheable_value = if value.is_a?(Hash)
+                          clean_hash = {}
+                          value.each do |k, v|
+                            clean_hash[k] = case v
+                                            when Hash then v.to_h
+                                            when Array then v.map { |item| item.is_a?(Hash) ? item.to_h : item }
+                                            else v
+                                            end
+                          end
+                          clean_hash
+                        else
+                          value
+                        end
+      cache.write(cache_key(type, key), cacheable_value, expires_in: @cache_time)
+    end
+
+    # Alias for writing without API call
+    def write(type, value, key = nil)
+      type = type.to_s unless type.is_a? String
+      return unless cache_available?
+
+      # Convert to plain hash for caching to avoid serialization issues
+      cacheable_value = if value.is_a?(Hash)
+                          clean_hash = {}
+                          value.each do |k, v|
+                            clean_hash[k] = case v
+                                            when Hash then v.to_h
+                                            when Array then v.map { |item| item.is_a?(Hash) ? item.to_h : item }
+                                            else v
+                                            end
+                          end
+                          clean_hash
+                        else
+                          value
+                        end
+      cache.write(cache_key(type, key), cacheable_value, expires_in: @cache_time)
+    end
+
+    private
+
+    def cache_key(type, key = nil)
+      "activematrix:room:#{room.id}:state:#{type}#{"|#{key}" if key}"
+    end
+
+    def cache_available?
+      defined?(::Rails) && ::Rails.respond_to?(:cache) && ::Rails.cache
+    end
+
+    def cache
+      ::Rails.cache
+    end
+  end
+end

data/lib/{matrix_sdk → active_matrix}/util/uri.rb

@@ -25,8 +25,8 @@ module URI
     class MATRIX < Generic
       attr_reader :authority, :action, :mxid, :mxid2, :via
 
-      def initialize(*args)
-        super(*args)
+      def initialize(*)
+        super
 
         @action = nil
         @authority = nil
@@ -64,7 +64,7 @@ module URI
         component = components.shift
         raise InvalidComponentError, "component can't be empty" if component.nil? || component.empty?
 
-        @mxid = MatrixSdk::MXID.new("#{sigil}#{component}")
+        @mxid = ActiveMatrix::MXID.new("#{sigil}#{component}")
 
         if components.size == 2
           sigil2 = case components.shift
@@ -76,7 +76,7 @@ module URI
           component = components.shift
           raise InvalidComponentError, "component can't be empty" if component.nil? || component.empty?
 
-          @mxid2 = MatrixSdk::MXID.new("#{sigil2}#{component}")
+          @mxid2 = ActiveMatrix::MXID.new("#{sigil2}#{component}")
         end
 
         return unless @query

data/lib/active_matrix/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  VERSION = '0.0.2'
+end

data/lib/active_matrix.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'active_matrix/version'
+require_relative 'active_matrix/logging'
+require_relative 'active_matrix/util/extensions'
+require_relative 'active_matrix/util/uri'
+require_relative 'active_matrix/util/events'
+require_relative 'active_matrix/errors'
+
+require 'json'
+require 'zeitwerk'
+require 'active_support'
+require 'active_support/core_ext/integer/time'
+require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/blank'
+
+module ActiveMatrix
+  # Configuration
+  class << self
+    attr_accessor :config
+
+    def configure
+      @config ||= Configuration.new
+      yield @config if block_given?
+      @config
+    end
+  end
+
+  # Configuration class
+  class Configuration
+    attr_accessor :agent_startup_delay, :max_agents_per_process,
+                  :agent_health_check_interval, :conversation_history_limit,
+                  :conversation_stale_after, :memory_cleanup_interval,
+                  :event_queue_size, :event_processing_timeout,
+                  :max_clients_per_homeserver, :client_idle_timeout,
+                  :agent_log_level, :log_agent_events
+
+    def initialize
+      # Set defaults
+      @agent_startup_delay = 2
+      @max_agents_per_process = 10
+      @agent_health_check_interval = 30
+      @conversation_history_limit = 20
+      @conversation_stale_after = 86_400 # 1 day
+      @memory_cleanup_interval = 3600 # 1 hour
+      @event_queue_size = 1000
+      @event_processing_timeout = 30
+      @max_clients_per_homeserver = 5
+      @client_idle_timeout = 300 # 5 minutes
+      @agent_log_level = :info
+      @log_agent_events = false
+    end
+  end
+
+  # Set up Zeitwerk loader
+  Loader = Zeitwerk::Loader.for_gem
+
+  # Ignore directories that shouldn't be autoloaded
+  Loader.ignore("#{__dir__}/generators")
+
+  # Configure inflections for special cases
+  Loader.inflector.inflect(
+    'mxid' => 'MXID',
+    'uri' => 'URI',
+    'as' => 'AS',
+    'cs' => 'CS',
+    'is' => 'IS',
+    'ss' => 'SS',
+    'msc' => 'MSC'
+  )
+
+  # Setup Zeitwerk autoloading
+  Loader.setup
+
+  # Eager load all classes if in Rails eager loading mode
+  Loader.eager_load if defined?(Rails) && Rails.respond_to?(:application) && Rails.application&.config&.eager_load
+
+  # Load Railtie for Rails integration
+  require 'active_matrix/railtie' if defined?(Rails::Railtie)
+end

data/lib/generators/active_matrix/bot/bot_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module ActiveMatrix
+  module Generators
+    class BotGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates a new ActiveMatrix bot'
+
+      argument :commands, type: :array, default: [], banner: 'command1 command2'
+
+      def create_bot_file
+        template 'bot.rb.erb', "app/bots/#{file_name}_bot.rb"
+      end
+
+      def create_bot_spec
+        template 'bot_spec.rb.erb', "spec/bots/#{file_name}_bot_spec.rb"
+      end
+
+      def display_usage
+        say "\nBot created! To use your bot:\n\n"
+        say '1. Create an agent in Rails console:'
+        say '   agent = MatrixAgent.create!('
+        say "     name: '#{file_name}',"
+        say "     homeserver: 'https://matrix.org',"
+        say "     username: 'your_bot_username',"
+        say "     password: 'your_bot_password',"
+        say "     bot_class: '#{class_name}Bot'"
+        say '   )'
+        say "\n2. Start the agent:"
+        say '   ActiveMatrix::AgentManager.instance.start_agent(agent)'
+        say "\n"
+      end
+    end
+  end
+end

data/lib/generators/active_matrix/bot/templates/bot.rb.erb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+class <%= class_name %>Bot < ActiveMatrix::Bot::MultiInstanceBase
+  # Bot configuration
+  set :accept_invites, true
+  set :command_prefix, '!'
+  
+  # Set a custom help preamble
+  set :help_preamble, "I am <%= class_name %>, ready to assist!"
+  
+  <% if commands.any? %>
+  # Generated commands
+  <% commands.each do |command| %>
+  command :<%= command %>,
+          desc: 'TODO: Add description for <%= command %>',
+          args: 'TODO: Add arguments' do |*args|
+    # TODO: Implement <%= command %> command
+    room.send_notice("Command <%= command %> called with args: #{args.inspect}")
+    
+    # Example of using agent memory
+    count = memory.increment("<%= command %>_count")
+    room.send_notice("This command has been used #{count} times")
+    
+    # Example of using conversation context
+    context = conversation_context
+    update_context(last_command: '<%= command %>')
+  end
+  
+  <% end %>
+  <% else %>
+  # Example command
+  command :hello,
+          desc: 'Say hello',
+          args: '[name]' do |name = nil|
+    greeting = name ? "Hello, #{name}!" : "Hello there!"
+    room.send_notice(greeting)
+    
+    # Remember who we greeted in conversation memory
+    if name
+      names_greeted = conversation_memory.remember(:names_greeted) { [] }
+      unless names_greeted.include?(name)
+        names_greeted << name
+        conversation_memory[:names_greeted] = names_greeted
+      end
+    end
+  end
+  
+  # Example command with agent communication
+  command :broadcast,
+          desc: 'Broadcast a message to all agents',
+          args: 'message' do |*message|
+    msg = message.join(' ')
+    
+    # Broadcast to all online agents
+    broadcast_to_agents(:online, {
+      type: 'announcement',
+      message: msg,
+      from_room: room.id
+    })
+    
+    room.send_notice("Broadcast sent: #{msg}")
+  end
+  <% end %>
+  
+  # Example event handler
+  event 'm.room.member' do
+    if event[:content][:membership] == 'join' && event[:state_key] != client.mxid
+      # Someone joined the room
+      user = client.get_user(event[:state_key])
+      room.send_notice("Welcome, #{user.display_name || user.id}!")
+      
+      # Track room members in agent memory
+      members = memory.get(:room_members) || {}
+      members[room.id] ||= []
+      members[room.id] << event[:state_key] unless members[room.id].include?(event[:state_key])
+      memory.set(:room_members, members)
+    end
+  end
+  
+  # Handle inter-agent messages
+  def receive_message(data, from:)
+    case data[:type]
+    when 'ping'
+      # Respond to ping
+      send_to_agent(from.agent_name, { type: 'pong', timestamp: Time.current })
+    else
+      logger.info "Received message from #{from.agent_name}: #{data.inspect}"
+    end
+  end
+  
+  # Handle broadcasts
+  def receive_broadcast(data, from:)
+    case data[:type]
+    when 'announcement'
+      # Could relay announcements to specific rooms
+      logger.info "Received announcement from #{from.agent_name}: #{data[:message]}"
+    end
+  end
+  
+  # Custom helper methods
+  private
+  
+  def greeting_for_time
+    hour = Time.current.hour
+    case hour
+    when 0..11 then "Good morning"
+    when 12..17 then "Good afternoon"
+    when 18..23 then "Good evening"
+    end
+  end
+end

data/lib/generators/active_matrix/bot/templates/bot_spec.rb.erb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe <%= class_name %>Bot do
+  let(:agent) do
+    MatrixAgent.create!(
+      name: '<%= file_name %>_test',
+      homeserver: 'https://matrix.example.com',
+      username: 'test_bot',
+      password: 'password',
+      bot_class: '<%= class_name %>Bot'
+    )
+  end
+  
+  let(:client) { instance_double(ActiveMatrix::Client) }
+  let(:room) { instance_double(ActiveMatrix::Room) }
+  let(:bot) { described_class.new(agent) }
+  
+  before do
+    allow(agent).to receive(:client).and_return(client)
+    allow(client).to receive(:mxid).and_return('@test_bot:example.com')
+    allow(bot).to receive(:room).and_return(room)
+  end
+  
+  <% if commands.any? %>
+  <% commands.each do |command| %>
+  describe '#<%= command %>' do
+    it 'responds to the <%= command %> command' do
+      expect(room).to receive(:send_notice).twice
+      bot.send(:<%= command %>)
+    end
+  end
+  
+  <% end %>
+  <% else %>
+  describe '#hello' do
+    it 'responds with a greeting' do
+      expect(room).to receive(:send_notice).with('Hello there!')
+      bot.hello
+    end
+    
+    it 'greets by name when provided' do
+      expect(room).to receive(:send_notice).with('Hello, Alice!')
+      bot.hello('Alice')
+    end
+  end
+  <% end %>
+  
+  describe 'inter-agent communication' do
+    let(:other_bot) { instance_double(ActiveMatrix::Bot::MultiInstanceBase, agent_name: 'other_bot') }
+    
+    it 'responds to ping messages' do
+      expect(bot).to receive(:send_to_agent).with('other_bot', hash_including(type: 'pong'))
+      bot.receive_message({ type: 'ping' }, from: other_bot)
+    end
+  end
+  
+  describe 'memory access' do
+    it 'has access to agent memory' do
+      expect(bot.memory).to be_a(ActiveMatrix::Memory::AgentMemory)
+    end
+    
+    it 'has access to global memory' do
+      expect(bot.global_memory).to be_a(ActiveMatrix::Memory::GlobalMemory)
+    end
+  end
+end