activematrix 0.0.1 → 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/active_matrix/util/extensions.rb

@@ -8,6 +8,10 @@ unless Object.respond_to? :yield_self
   end
 end
 
+# Time.current is provided by ActiveSupport
+
+# Time duration helpers are provided by ActiveSupport
+
 module ActiveMatrix
   module Extensions
     def events(*symbols)

data/lib/active_matrix/util/state_event_cache.rb

@@ -3,14 +3,13 @@
 module ActiveMatrix::Util
   class StateEventCache
     extend ActiveMatrix::Extensions
-    extend ActiveMatrix::Util::Tinycache
     include Enumerable
 
     attr_reader :room
 
     attr_accessor :cache_time
 
-    ignore_inspect :client, :room, :tinycache_adapter
+    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
@@ -24,21 +23,18 @@ module ActiveMatrix::Util
     end
 
     def reload!
-      tinycache_adapter.clear
+      # Clear all cache entries for this room's state
+      cache.delete_matched("activematrix:room:#{room.id}:state:*") if cache_available?
     end
 
     def keys
-      tinycache_adapter.send(:cache).keys.map do |type|
-        real_type = type.split('|').first
-        state_key = type.split('|').last
-        state_key = nil if state_key == real_type
-
-        [real_type, state_key]
-      end
+      # State is not enumerable when using Rails.cache
+      # This would require keeping track of keys separately
+      []
     end
 
     def values
-      keys.map { |key| tinycache_adapter.read(key) }
+      []
     end
 
     def size
@@ -46,47 +42,126 @@ module ActiveMatrix::Util
     end
 
     def key?(type, key = nil)
-      keys.key?("#{type}#{"|#{key}" if key}")
+      cache_available? && cache.exist?(cache_key(type, key))
     end
 
     def expire(type, key = nil)
-      tinycache_adapter.expire("#{type}#{"|#{key}" if key}")
+      cache.delete(cache_key(type, key)) if cache_available?
     end
 
     def each(live: false)
-      return to_enum(__method__, live: live) { keys.count } unless block_given?
-
-      keys.each do |type|
-        real_type = type.split('|').first
-        state_key = type.split('|').last
-        state_key = nil if state_key == real_type
-
-        v = live ? self[real_type, key: state_key] : tinycache_adapter.read(type)
-        # hash = v.hash
-        yield [real_type, state_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(type, key = nil)
       type = type.to_s unless type.is_a? String
       client.api.set_room_state(room.id, type, {}, **{ state_key: key }.compact)
-      tinycache_adapter.delete("#{type}#{"|#{key}" if key}")
+      cache.delete(cache_key(type, key)) if cache_available?
     end
 
     def [](type, key = nil)
       type = type.to_s unless type.is_a? String
-      tinycache_adapter.fetch("#{type}#{"|#{key}" if key}", expires_in: @cache_time) do
-        client.api.get_room_state(room.id, type, **{ key: key }.compact)
-      rescue ActiveMatrix::MatrixNotFoundError
-        {}
+      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)
-      tinycache_adapter.write("#{type}#{"|#{key}" if key}", value)
+
+      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/active_matrix/version.rb

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

data/lib/active_matrix.rb

@@ -9,25 +9,73 @@ 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', 
+    '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

data/lib/generators/active_matrix/install/install_generator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module ActiveMatrix
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates ActiveMatrix migrations and initializers'
+
+      def create_migrations
+        migration_template 'create_matrix_agents.rb', 'db/migrate/create_matrix_agents.rb'
+        migration_template 'create_agent_memories.rb', 'db/migrate/create_agent_memories.rb'
+        migration_template 'create_conversation_contexts.rb', 'db/migrate/create_conversation_contexts.rb'
+        migration_template 'create_global_memories.rb', 'db/migrate/create_global_memories.rb'
+      end
+
+      def create_initializer
+        template 'active_matrix.rb', 'config/initializers/active_matrix.rb'
+      end
+
+      def create_models
+        template 'matrix_agent.rb', 'app/models/matrix_agent.rb'
+        template 'agent_memory.rb', 'app/models/agent_memory.rb'
+        template 'conversation_context.rb', 'app/models/conversation_context.rb'
+        template 'global_memory.rb', 'app/models/global_memory.rb'
+      end
+
+      def display_post_install
+        readme 'README' if behavior == :invoke
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/active_matrix/install/templates/README

@@ -0,0 +1,30 @@
+===============================================================================
+
+ActiveMatrix Multi-Agent System has been installed!
+
+Next steps:
+
+1. Run migrations:
+   rails db:migrate
+
+2. Create your first bot:
+   rails generate active_matrix:bot MyFirstBot
+
+3. Configure your agents in the Rails console:
+   agent = MatrixAgent.create!(
+     name: 'captain',
+     homeserver: 'https://matrix.org',
+     username: 'captain_bot',
+     password: 'secure_password',
+     bot_class: 'MyFirstBot'
+   )
+
+4. Start the agent system:
+   ActiveMatrix::AgentManager.instance.start_all
+
+Or start individual agents:
+   ActiveMatrix::AgentManager.instance.start_agent(agent)
+
+For more information, visit: https://github.com/seuros/agent_smith
+
+===============================================================================

data/lib/generators/active_matrix/install/templates/active_matrix.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# ActiveMatrix configuration
+ActiveMatrix.configure do |config|
+  # Agent configuration
+  config.agent_startup_delay = 2.seconds # Delay between starting each agent
+  config.max_agents_per_process = 10     # Maximum agents in a single process
+  config.agent_health_check_interval = 30.seconds
+
+  # Memory configuration
+  config.conversation_history_limit = 20
+  config.conversation_stale_after = 1.day
+  config.memory_cleanup_interval = 1.hour
+
+  # Event routing configuration
+  config.event_queue_size = 1000
+  config.event_processing_timeout = 30.seconds
+
+  # Client pool configuration
+  config.max_clients_per_homeserver = 5
+  config.client_idle_timeout = 5.minutes
+
+  # Logging
+  config.agent_log_level = :info
+  config.log_agent_events = Rails.env.development?
+end
+
+# Start agent manager on Rails boot (can be disabled in environments)
+if Rails.env.production? || ENV['START_AGENTS'].present?
+  Rails.application.config.after_initialize do
+    ActiveMatrix::AgentManager.instance.start_all
+  end
+end