activematrix 0.0.1 → 0.0.2

data/lib/active_matrix/event_router.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'concurrent'
+
+module ActiveMatrix
+  # Routes Matrix events to appropriate agents
+  class EventRouter
+    include Singleton
+    include ActiveMatrix::Logging
+
+    def initialize
+      @routes = Concurrent::Array.new
+      @event_queue = Queue.new
+      @processing = false
+      @worker_thread = nil
+    end
+
+    # Register an event route
+    def register_route(agent_id:, room_id: nil, event_type: nil, user_id: nil, priority: 50, &block)
+      route = {
+        id: SecureRandom.uuid,
+        agent_id: agent_id,
+        room_id: room_id,
+        event_type: event_type,
+        user_id: user_id,
+        priority: priority,
+        handler: block
+      }
+
+      @routes << route
+      @routes.sort_by! { |r| -r[:priority] } # Higher priority first
+
+      logger.debug "Registered route: #{route.except(:handler).inspect}"
+      route[:id]
+    end
+
+    # Unregister a route
+    def unregister_route(route_id)
+      @routes.delete_if { |route| route[:id] == route_id }
+    end
+
+    # Clear all routes for an agent
+    def clear_agent_routes(agent_id)
+      @routes.delete_if { |route| route[:agent_id] == agent_id }
+    end
+
+    # Route an event to appropriate agents
+    def route_event(event)
+      return unless @processing
+
+      # Queue the event for processing
+      @event_queue << event
+    end
+
+    # Start the event router
+    def start
+      return if @processing
+
+      @processing = true
+      @worker_thread = Thread.new do
+        Thread.current.name = 'event-router'
+        process_events
+      end
+
+      logger.info 'Event router started'
+    end
+
+    # Stop the event router
+    def stop
+      @processing = false
+      @worker_thread&.kill
+      @event_queue.clear
+
+      logger.info 'Event router stopped'
+    end
+
+    # Check if router is running
+    def running?
+      @processing && @worker_thread&.alive?
+    end
+
+    # Get routes for debugging
+    def routes_summary
+      @routes.map { |r| r.except(:handler) }
+    end
+
+    # Broadcast an event to all agents
+    def broadcast_event(event)
+      AgentRegistry.instance.all_instances.each do |bot|
+        bot._handle_event(event) if bot.respond_to?(:_handle_event)
+      rescue StandardError => e
+        logger.error "Error broadcasting to bot: #{e.message}"
+      end
+    end
+
+    private
+
+    def process_events
+      while @processing
+        begin
+          # Wait for event with timeout
+          event = nil
+          Timeout.timeout(1) { event = @event_queue.pop }
+
+          next unless event
+
+          # Find matching routes
+          matching_routes = find_matching_routes(event)
+
+          if matching_routes.empty?
+            logger.debug "No routes matched for event: #{event[:type]} in #{event[:room_id]}"
+            next
+          end
+
+          # Process routes in priority order
+          matching_routes.each do |route|
+            process_route(route, event)
+          end
+        rescue Timeout::Error
+          # Normal timeout, continue loop
+        rescue StandardError => e
+          logger.error "Event router error: #{e.message}"
+          logger.error e.backtrace.join("\n")
+        end
+      end
+    end
+
+    def find_matching_routes(event)
+      @routes.select do |route|
+        # Check room match
+        next false if route[:room_id] && route[:room_id] != event[:room_id]
+
+        # Check event type match
+        next false if route[:event_type] && route[:event_type] != event[:type]
+
+        # Check user match
+        next false if route[:user_id] && route[:user_id] != event[:sender]
+
+        # Check if agent is running
+        registry = AgentRegistry.instance
+        agent_entry = registry.get(route[:agent_id])
+        next false unless agent_entry
+
+        true
+      end
+    end
+
+    def process_route(route, event)
+      registry = AgentRegistry.instance
+      agent_entry = registry.get(route[:agent_id])
+
+      return unless agent_entry
+
+      bot = agent_entry[:instance]
+
+      begin
+        if route[:handler]
+          # Custom handler
+          route[:handler].call(bot, event)
+        elsif bot.respond_to?(:_handle_event)
+          # Default handling
+          bot._handle_event(event)
+        end
+      rescue StandardError => e
+        logger.error "Error processing route for agent #{agent_entry[:record].name}: #{e.message}"
+        logger.error e.backtrace.first(5).join("\n")
+      end
+    end
+  end
+
+  # Routing DSL for bots
+  module Bot
+    class MultiInstanceBase
+      # Route events to this bot
+      def self.route(event_type: nil, room_id: nil, user_id: nil, priority: 50, &block)
+        # Routes will be registered when bot instance is created
+        @event_routes ||= []
+        @event_routes << {
+          event_type: event_type,
+          room_id: room_id,
+          user_id: user_id,
+          priority: priority,
+          handler: block
+        }
+      end
+
+      # Get defined routes
+      def self.event_routes
+        @event_routes || []
+      end
+
+      # Register routes for this instance
+      def register_routes
+        return unless @agent_record
+
+        router = EventRouter.instance
+
+        self.class.event_routes.each do |route_def|
+          router.register_route(
+            agent_id: @agent_record.id,
+            **route_def
+          )
+        end
+      end
+
+      # Clear routes for this instance
+      def clear_routes
+        return unless @agent_record
+
+        EventRouter.instance.clear_agent_routes(@agent_record.id)
+      end
+    end
+  end
+end

data/lib/active_matrix/memory/agent_memory.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  module Memory
+    # Per-agent private memory storage
+    class AgentMemory < Base
+      attr_reader :agent
+
+      def initialize(agent)
+        super()
+        @agent = agent
+      end
+
+      # Get a value from agent memory
+      def get(key)
+        fetch_with_cache(key) do
+          return nil unless defined?(::AgentMemory)
+
+          memory = @agent.agent_memories.active.find_by(key: key)
+          memory&.value
+        end
+      end
+
+      # Set a value in agent memory
+      def set(key, value, expires_in: nil)
+        return false unless defined?(::AgentMemory)
+
+        write_through(key, value, expires_in: expires_in) do
+          memory = @agent.agent_memories.find_or_initialize_by(key: key)
+          memory.value = value
+          memory.expires_at = expires_in.present? ? Time.current + expires_in : nil
+          memory.save!
+        end
+      end
+
+      # Check if a key exists
+      def exists?(key)
+        return false unless defined?(::AgentMemory)
+
+        if @cache_enabled && Rails.cache.exist?(cache_key(key))
+          true
+        else
+          @agent.agent_memories.active.exists?(key: key)
+        end
+      end
+
+      # Delete a key
+      def delete(key)
+        return false unless defined?(::AgentMemory)
+
+        delete_through(key) do
+          @agent.agent_memories.where(key: key).destroy_all.any?
+        end
+      end
+
+      # Get all keys
+      def keys
+        return [] unless defined?(::AgentMemory)
+
+        @agent.agent_memories.active.pluck(:key)
+      end
+
+      # Get all memory as hash
+      def all
+        return {} unless defined?(::AgentMemory)
+
+        @agent.agent_memories.active.pluck(:key, :value).to_h
+      end
+
+      # Clear all agent memory
+      def clear!
+        return false unless defined?(::AgentMemory)
+
+        @agent.agent_memories.destroy_all
+
+        # Clear cache entries
+        keys.each { |key| Rails.cache.delete(cache_key(key)) } if @cache_enabled
+
+        true
+      end
+
+      # Remember something with optional TTL
+      def remember(key, expires_in: nil)
+        value = get(key)
+        return value if value.present?
+
+        value = yield
+        set(key, value, expires_in: expires_in) if value.present?
+        value
+      end
+
+      # Increment a counter
+      def increment(key, amount = 1)
+        current = get(key) || 0
+        new_value = current + amount
+        set(key, new_value)
+        new_value
+      end
+
+      # Decrement a counter
+      def decrement(key, amount = 1)
+        increment(key, -amount)
+      end
+
+      # Add to a list
+      def push(key, value)
+        list = get(key) || []
+        list << value
+        set(key, list)
+        list
+      end
+
+      # Remove from a list
+      def pull(key, value)
+        list = get(key) || []
+        list.delete(value)
+        set(key, list)
+        list
+      end
+
+      protected
+
+      def cache_key(key)
+        "agent_memory/#{@agent.id}/#{key}"
+      end
+    end
+  end
+end

data/lib/active_matrix/memory/base.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  module Memory
+    # Base class for memory implementations
+    class Base
+      include ActiveMatrix::Logging
+
+      def initialize
+        @cache_enabled = Rails.cache.present? rescue false
+      end
+
+      # Get a value from memory
+      def get(key)
+        raise NotImplementedError
+      end
+
+      # Set a value in memory
+      def set(key, value, expires_in: nil)
+        raise NotImplementedError
+      end
+
+      # Check if a key exists
+      def exists?(key)
+        raise NotImplementedError
+      end
+
+      # Delete a key
+      def delete(key)
+        raise NotImplementedError
+      end
+
+      # Get multiple keys at once
+      def get_multi(*keys)
+        keys.to_h { |key| [key, get(key)] }
+      end
+
+      # Set multiple keys at once
+      def set_multi(hash, expires_in: nil)
+        hash.each { |key, value| set(key, value, expires_in: expires_in) }
+      end
+
+      # Clear all memory (use with caution)
+      def clear!
+        raise NotImplementedError
+      end
+
+      protected
+
+      # Generate cache key
+      def cache_key(key)
+        raise NotImplementedError
+      end
+
+      # Try cache first, then database
+      def fetch_with_cache(key, expires_in: nil)
+        return yield unless @cache_enabled
+
+        cached_key = cache_key(key)
+
+        # Try cache first
+        cached = Rails.cache.read(cached_key)
+        return cached if cached.present?
+
+        # Get from source
+        value = yield
+        return nil if value.nil?
+
+        # Write to cache
+        Rails.cache.write(cached_key, value, expires_in: expires_in)
+        value
+      end
+
+      # Write through to cache and database
+      def write_through(key, value, expires_in: nil)
+        cached_key = cache_key(key)
+
+        # Write to database first
+        result = yield
+
+        # Then update cache if enabled
+        Rails.cache.write(cached_key, value, expires_in: expires_in) if @cache_enabled && result
+
+        result
+      end
+
+      # Delete from cache and database
+      def delete_through(key)
+        cached_key = cache_key(key)
+
+        # Delete from database
+        result = yield
+
+        # Delete from cache if enabled
+        Rails.cache.delete(cached_key) if @cache_enabled
+
+        result
+      end
+    end
+  end
+end

data/lib/active_matrix/memory/conversation_memory.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  module Memory
+    # Per-conversation memory storage (speaker-specific)
+    class ConversationMemory < Base
+      attr_reader :agent, :user_id, :room_id
+
+      def initialize(agent, user_id, room_id)
+        super()
+        @agent = agent
+        @user_id = user_id
+        @room_id = room_id
+      end
+
+      # Get conversation context
+      def context
+        fetch_with_cache('context', expires_in: 1.hour) do
+          return {} unless defined?(::ConversationContext)
+
+          record = find_or_create_record
+          record.context
+        end
+      end
+
+      # Update conversation context
+      def update_context(data)
+        return false unless defined?(::ConversationContext)
+
+        record = find_or_create_record
+        record.context = record.context.merge(data)
+        record.save!
+
+        # Update cache
+        invalidate_cache
+        true
+      end
+
+      # Add a message to history
+      def add_message(event)
+        return false unless defined?(::ConversationContext)
+
+        record = find_or_create_record
+        record.add_message({
+                             event_id: event[:event_id],
+                             sender: event[:sender],
+                             content: event.dig(:content, :body),
+                             timestamp: event[:origin_server_ts] || (Time.current.to_i * 1000)
+                           })
+
+        # Update agent activity
+        @agent.update_activity!
+        @agent.increment_messages_handled!
+
+        # Invalidate cache
+        invalidate_cache
+        true
+      end
+
+      # Get recent messages
+      def recent_messages(limit = 10)
+        fetch_with_cache('recent_messages', expires_in: 5.minutes) do
+          return [] unless defined?(::ConversationContext)
+
+          record = find_or_create_record
+          record.recent_messages(limit)
+        end
+      end
+
+      # Get last message timestamp
+      def last_message_at
+        return nil unless defined?(::ConversationContext)
+
+        record = conversation_record
+        record&.last_message_at
+      end
+
+      # Check if conversation is active (recent activity)
+      def active?
+        last_at = last_message_at
+        last_at.present? && last_at > 1.hour.ago
+      end
+
+      # Clear conversation history but keep context
+      def clear_history!
+        return false unless defined?(::ConversationContext)
+
+        record = conversation_record
+        return false unless record
+
+        record.prune_history!
+        invalidate_cache
+        true
+      end
+
+      # Get or set a specific context value
+      def [](key)
+        context[key.to_s]
+      end
+
+      def []=(key, value)
+        update_context(key.to_s => value)
+      end
+
+      # Remember something in conversation context
+      def remember(key)
+        value = self[key]
+        return value if value.present?
+
+        value = yield
+        self[key] = value if value.present?
+        value
+      end
+
+      # Get conversation summary
+      def summary
+        {
+          user_id: @user_id,
+          room_id: @room_id,
+          active: active?,
+          message_count: conversation_record&.message_count || 0,
+          last_message_at: last_message_at,
+          context: context
+        }
+      end
+
+      protected
+
+      def cache_key(suffix)
+        "conversation/#{@agent.id}/#{@user_id}/#{@room_id}/#{suffix}"
+      end
+
+      def conversation_record
+        return nil unless defined?(::ConversationContext)
+
+        ::ConversationContext.find_by(
+          matrix_agent: @agent,
+          user_id: @user_id,
+          room_id: @room_id
+        )
+      end
+
+      def find_or_create_record
+        return nil unless defined?(::ConversationContext)
+
+        ::ConversationContext.find_or_create_by!(
+          matrix_agent: @agent,
+          user_id: @user_id,
+          room_id: @room_id
+        )
+      end
+
+      def invalidate_cache
+        return unless @cache_enabled
+
+        Rails.cache.delete(cache_key('context'))
+        Rails.cache.delete(cache_key('recent_messages'))
+      end
+    end
+  end
+end