activematrix 0.0.5 → 0.0.8

data/app/models/active_matrix/chat_session.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# <rails-lens:schema:begin>
+# table = "active_matrix_chat_sessions"
+# database_dialect = "PostgreSQL"
+#
+# columns = [
+#   { name = "id", type = "integer", pk = true, null = false },
+#   { name = "agent_id", type = "integer", null = false },
+#   { name = "user_id", type = "string", null = false },
+#   { name = "room_id", type = "string", null = false },
+#   { name = "context", type = "json" },
+#   { name = "message_history", type = "json" },
+#   { name = "last_message_at", type = "datetime" },
+#   { name = "message_count", type = "integer", null = false, default = "0" },
+#   { name = "created_at", type = "datetime", null = false },
+#   { name = "updated_at", type = "datetime", null = false }
+# ]
+#
+# indexes = [
+#   { name = "index_active_matrix_chat_sessions_on_agent_id", columns = ["agent_id"] },
+#   { name = "index_active_matrix_chat_sessions_on_last_message_at", columns = ["last_message_at"] },
+#   { name = "index_chat_sessions_on_agent_user_room", columns = ["agent_id", "user_id", "room_id"], unique = true }
+# ]
+#
+# foreign_keys = [
+#   { column = "agent_id", references_table = "active_matrix_agents", references_column = "id", name = "fk_rails_53457da357" }
+# ]
+#
+# notes = ["agent:INVERSE_OF", "context:NOT_NULL", "message_history:NOT_NULL", "user_id:LIMIT", "room_id:LIMIT"]
+# <rails-lens:schema:end>
+module ActiveMatrix
+  class ChatSession < ApplicationRecord
+    self.table_name = 'active_matrix_chat_sessions'
+
+    belongs_to :agent, class_name: 'ActiveMatrix::Agent'
+
+    validates :user_id, presence: true
+    validates :room_id, presence: true
+    validates :user_id, uniqueness: { scope: %i[agent_id room_id] }
+
+    # Configuration
+    MAX_HISTORY_SIZE = 20
+
+    # Scopes
+    scope :recent, -> { order(last_message_at: :desc) }
+    scope :active, -> { where('last_message_at > ?', 1.hour.ago) }
+    scope :stale, -> { where(last_message_at: ...1.day.ago) }
+
+    # Add a message to the history
+    def add_message(message_data)
+      messages = message_history['messages'] || []
+
+      # Add new message
+      messages << {
+        'event_id' => message_data[:event_id],
+        'sender' => message_data[:sender],
+        'content' => message_data[:content],
+        'timestamp' => message_data[:timestamp] || Time.current.to_i
+      }
+
+      # Keep only recent messages
+      messages = messages.last(MAX_HISTORY_SIZE)
+
+      # Update record
+      self.message_history = { 'messages' => messages }
+      self.last_message_at = Time.current
+      self.message_count = messages.size
+      save!
+
+      # Update cache
+      write_to_cache
+    end
+
+    # Get recent messages
+    def recent_messages(limit = 10)
+      messages = message_history['messages'] || []
+      messages.last(limit)
+    end
+
+    # Clear old messages but keep context
+    def prune_history!
+      messages = message_history['messages'] || []
+      self.message_history = { 'messages' => messages.last(5) }
+      save!
+    end
+
+    # Cache integration
+    def cache_key
+      "conversation/#{agent_id}/#{user_id}/#{room_id}"
+    end
+
+    def write_to_cache
+      Rails.cache.write(cache_key, {
+                          context: context,
+                          recent_messages: recent_messages,
+                          last_message_at: last_message_at
+                        }, expires_in: 1.hour)
+    end
+
+    def self.cleanup_stale!
+      stale.destroy_all
+    end
+  end
+end

data/app/models/active_matrix/knowledge_base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# <rails-lens:schema:begin>
+# table = "active_matrix_knowledge_bases"
+# database_dialect = "PostgreSQL"
+#
+# columns = [
+#   { name = "id", type = "integer", pk = true, null = false },
+#   { name = "key", type = "string", null = false },
+#   { name = "value", type = "json" },
+#   { name = "category", type = "string" },
+#   { name = "expires_at", type = "datetime" },
+#   { name = "public_read", type = "boolean", null = false, default = "true" },
+#   { name = "public_write", type = "boolean", null = false, default = "false" },
+#   { name = "created_at", type = "datetime", null = false },
+#   { name = "updated_at", type = "datetime", null = false }
+# ]
+#
+# indexes = [
+#   { name = "index_active_matrix_knowledge_bases_on_category", columns = ["category"] },
+#   { name = "index_active_matrix_knowledge_bases_on_expires_at", columns = ["expires_at"] },
+#   { name = "index_active_matrix_knowledge_bases_on_key", columns = ["key"], unique = true },
+#   { name = "index_active_matrix_knowledge_bases_on_public_read", columns = ["public_read"] },
+#   { name = "index_active_matrix_knowledge_bases_on_public_write", columns = ["public_write"] }
+# ]
+#
+# notes = ["value:NOT_NULL", "category:NOT_NULL", "key:LIMIT", "category:LIMIT"]
+# <rails-lens:schema:end>
+module ActiveMatrix
+  class KnowledgeBase < ApplicationRecord
+    self.table_name = 'active_matrix_knowledge_bases'
+
+    validates :key, presence: true, uniqueness: true
+
+    scope :active, -> { where('expires_at IS NULL OR expires_at > ?', Time.current) }
+    scope :expired, -> { where(expires_at: ..Time.current) }
+    scope :by_category, ->(category) { where(category: category) }
+    scope :readable, -> { where(public_read: true) }
+    scope :writable, -> { where(public_write: true) }
+
+    def expired?
+      expires_at.present? && expires_at <= Time.current
+    end
+
+    def readable_by?(agent)
+      public_read || (agent.is_a?(ActiveMatrix::Agent) && agent.admin?)
+    end
+
+    def writable_by?(agent)
+      public_write || (agent.is_a?(ActiveMatrix::Agent) && agent.admin?)
+    end
+
+    # Cache integration
+    def cache_key
+      "global/#{key}"
+    end
+
+    def write_to_cache
+      return unless active?
+
+      ttl = expires_at.present? ? expires_at - Time.current : nil
+      Rails.cache.write(cache_key, value, expires_in: ttl)
+    end
+
+    def self.get(key)
+      # Try cache first
+      cached = Rails.cache.read("global/#{key}")
+      return cached if cached.present?
+
+      # Fallback to database
+      memory = find_by(key: key)
+      return unless memory&.active?
+
+      memory.write_to_cache
+      memory.value
+    end
+
+    def self.set(key, value, category: nil, expires_in: nil, public_read: true, public_write: false)
+      memory = find_or_initialize_by(key: key)
+      memory.value = value
+      memory.category = category
+      memory.expires_at = expires_in.present? ? Time.current + expires_in : nil
+      memory.public_read = public_read
+      memory.public_write = public_write
+      memory.save!
+      memory.write_to_cache
+      memory
+    end
+
+    def self.cleanup_expired!
+      expired.destroy_all
+    end
+
+    private
+
+    def active?
+      !expired?
+    end
+  end
+end

data/exe/activematrix

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'active_matrix/cli'
+
+ActiveMatrix::CLI.start(ARGV)

data/lib/active_matrix/agent_manager.rb

@@ -1,43 +1,88 @@
 # frozen_string_literal: true
 
 require 'singleton'
+require 'async'
+require 'async/barrier'
+require 'async/semaphore'
 
 module ActiveMatrix
-  # Manages the lifecycle of Matrix bot agents
+  # Manages the lifecycle of Matrix bot agents using async fibers
   class AgentManager
     include Singleton
     include ActiveMatrix::Logging
 
+    # OpenTelemetry semantic conventions for messaging
+    OTEL_ATTRS = {
+      service: 'activematrix.agent_manager',
+      messaging_system: 'matrix'
+    }.freeze
+
     attr_reader :registry, :config
 
     def initialize
       @registry = AgentRegistry.instance
       @config = ActiveMatrix.config
-      @shutdown = false
-      @monitor_thread = nil
+      @barrier = nil
+      @monitor_task = nil
+      @running = false
+    end
 
-      setup_signal_handlers
+    # Install signal handlers for graceful shutdown.
+    # Call this explicitly if you want the gem to handle SIGINT/SIGTERM.
+    # By default, signal handling is left to the host application.
+    def install_signal_handlers!
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) do
+          stop_all
+          exit # rubocop:disable Rails/Exit
+        end
+      end
     end
 
     # Start all agents marked as active in the database
+    # This is the main entry point - runs the async reactor
     def start_all
-      return if @shutdown
+      agents = ActiveMatrix::Agent.where.not(state: :offline)
+      start_agents(agents)
+    end
 
-      logger.info 'Starting all active agents...'
+    # Start specific agents (used by daemon workers)
+    # @param agents [ActiveRecord::Relation, Array<Agent>] Agents to start
+    def start_agents(agents)
+      return if @running
 
-      agents = defined?(MatrixAgent) ? MatrixAgent.where.not(state: :offline) : []
-      agents.each_with_index do |agent, index|
-        sleep(config.agent_startup_delay || 2) if index.positive?
-        start_agent(agent)
-      end
+      @running = true
+      agents_array = agents.respond_to?(:to_a) ? agents.to_a : agents
+      logger.info "Starting #{agents_array.size} agents..."
+
+      Sync do
+        @barrier = Async::Barrier.new
+
+        # Start the event router for routing Matrix events
+        EventRouter.instance.start
 
-      start_monitor_thread
-      logger.info "Started #{@registry.count} agents"
+        startup_delay = config.agent_startup_delay || 2
+
+        agents_array.each_with_index do |agent, index|
+          sleep(startup_delay) if index.positive?
+          start_agent(agent)
+        end
+
+        start_monitor_task
+
+        logger.info "Started #{@registry.count} agents"
+
+        # Wait for all agent tasks to complete (blocks until shutdown)
+        @barrier.wait
+      ensure
+        @barrier&.stop
+        @running = false
+      end
     end
 
-    # Start a specific agent
+    # Start a specific agent as an async task
     def start_agent(agent)
-      return if @shutdown
+      return false unless @running
 
       if @registry.running?(agent)
         logger.warn "Agent #{agent.name} is already running"
@@ -47,51 +92,15 @@ module ActiveMatrix
       logger.info "Starting agent: #{agent.name}"
 
       begin
-        # Update state
         agent.connect!
 
-        # Create bot instance in a new thread
-        thread = Thread.new do
-          Thread.current.name = "agent-#{agent.name}"
-
-          begin
-            # Create client and bot instance
-            client = create_client_for_agent(agent)
-            bot_class = agent.bot_class.constantize
-            bot_instance = bot_class.new(client)
-
-            # Register the agent
-            @registry.register(agent, bot_instance)
-
-            # Authenticate if needed
-            if agent.access_token.present?
-              client.access_token = agent.access_token
-            else
-              client.login(agent.username, agent.password)
-              agent.update(access_token: client.access_token)
-            end
-
-            # Restore sync token if available
-            client.sync_token = agent.last_sync_token if agent.last_sync_token.present?
-
-            # Mark as online
-            agent.connection_established!
-
-            # Start the sync loop
-            client.start_listener_thread
-            client.instance_variable_get(:@sync_thread).join
-          rescue StandardError => e
-            logger.error "Error in agent #{agent.name}: #{e.message}"
-            logger.error e.backtrace.join("\n")
-            agent.encounter_error!
-            raise
-          ensure
-            @registry.unregister(agent)
-            agent.disconnect! if agent.may_disconnect?
-          end
+        task = @barrier.async do |subtask|
+          subtask.annotate "agent-#{agent.name}"
+          run_agent(agent)
         end
 
-        thread.abort_on_exception = true
+        # Store task reference for later control
+        @registry.register_task(agent, task)
         true
       rescue StandardError => e
         logger.error "Failed to start agent #{agent.name}: #{e.message}"
@@ -109,18 +118,15 @@ module ActiveMatrix
 
       begin
         # Stop the client sync
-        client = entry[:instance].client
-        client.stop_listener_thread if client.listening?
+        client = entry[:instance]&.client
+        client&.stop_listener if client&.listening?
 
         # Save sync token
-        agent.update(last_sync_token: client.sync_token) if client.sync_token.present?
+        agent.update(last_sync_token: client.sync_token) if client&.sync_token.present?
 
-        # Kill the thread if still alive
-        thread = entry[:thread]
-        if thread&.alive?
-          thread.kill
-          thread.join(5) # Wait up to 5 seconds
-        end
+        # Stop the async task gracefully
+        task = entry[:task]
+        task&.stop
 
         # Update state
         agent.disconnect! if agent.may_disconnect?
@@ -135,16 +141,17 @@ module ActiveMatrix
     # Stop all running agents
     def stop_all
       logger.info 'Stopping all agents...'
-      @shutdown = true
 
-      # Stop monitor thread
-      @monitor_thread&.kill
+      # Stop monitor task
+      @monitor_task&.stop
 
-      # Stop all agents
-      @registry.all_records.each do |agent|
-        stop_agent(agent)
-      end
+      # Stop event router
+      EventRouter.instance.stop
 
+      # Stop all agent tasks via barrier
+      @barrier&.stop
+
+      @running = false
       logger.info 'All agents stopped'
     end
 
@@ -164,8 +171,8 @@ module ActiveMatrix
 
       logger.info "Pausing agent: #{agent.name}"
 
-      client = entry[:instance].client
-      client.stop_listener_thread if client.listening?
+      client = entry[:instance]&.client
+      client&.stop_listener if client&.listening?
       agent.pause!
 
       true
@@ -181,8 +188,8 @@ module ActiveMatrix
       logger.info "Resuming agent: #{agent.name}"
 
       agent.resume!
-      client = entry[:instance].client
-      client.start_listener_thread
+      client = entry[:instance]&.client
+      client&.start_listener
       agent.connection_established!
 
       true
@@ -193,41 +200,79 @@ module ActiveMatrix
       {
         running: @registry.count,
         agents: @registry.health_status,
-        monitor_active: @monitor_thread&.alive? || false,
-        shutdown: @shutdown
+        monitor_active: @monitor_task&.alive? || false,
+        shutdown: !@running
       }
     end
 
+    # Check if currently running
+    def running?
+      @running
+    end
+
     private
 
-    def create_client_for_agent(agent)
-      # Use shared client pool if available
-      if defined?(ClientPool)
-        ClientPool.instance.get_client(agent.homeserver)
-      else
-        ActiveMatrix::Client.new(agent.homeserver,
-                                 client_cache: :some,
-                                 sync_filter_limit: 20)
+    def run_agent(agent)
+      Telemetry.trace('agent.run', attributes: agent_attributes(agent)) do |span|
+        # Create client and bot instance
+        client = create_client_for_agent(agent)
+        bot_class = agent.bot_class.constantize
+        bot_instance = bot_class.new(client)
+
+        # Register the agent
+        @registry.register(agent, bot_instance)
+
+        # Authenticate if needed
+        if agent.access_token.present?
+          client.access_token = agent.access_token
+        else
+          Telemetry.trace('agent.login', attributes: agent_attributes(agent)) do
+            client.login(agent.username, agent.password)
+            agent.update(access_token: client.access_token)
+          end
+        end
+
+        # Restore sync token if available
+        client.sync_token = agent.last_sync_token if agent.last_sync_token.present?
+
+        # Mark as online
+        agent.connection_established!
+        span&.add_event('agent.connected')
+
+        # Run the sync loop (blocks until stopped)
+        client.listen_forever
       end
+    rescue Async::Stop
+      logger.info "Agent #{agent.name} stopping gracefully"
+    rescue StandardError => e
+      Telemetry.record_exception(e, attributes: agent_attributes(agent))
+      logger.error "Error in agent #{agent.name}: #{e.message}"
+      logger.error e.backtrace.first(10).join("\n")
+      agent.encounter_error!
+      raise
+    ensure
+      @registry.unregister(agent)
+      agent.disconnect! if agent.may_disconnect?
     end
 
-    def start_monitor_thread
-      return if @monitor_thread&.alive?
+    def create_client_for_agent(agent)
+      ClientPool.instance.get_client(agent.homeserver)
+    end
 
-      @monitor_thread = Thread.new do
-        Thread.current.name = 'agent-monitor'
+    def start_monitor_task
+      return if @monitor_task&.alive?
 
-        loop do
-          break if @shutdown
+      health_interval = config.agent_health_check_interval || 30
 
-          begin
-            check_agent_health
-            cleanup_stale_data
-          rescue StandardError => e
-            logger.error "Monitor thread error: #{e.message}"
-          end
+      @monitor_task = Async(transient: true) do |task|
+        task.annotate 'agent-monitor'
 
-          sleep(config.agent_health_check_interval || 30)
+        loop do
+          sleep(health_interval)
+          check_agent_health
+          cleanup_stale_data
+        rescue StandardError => e
+          logger.error "Monitor task error: #{e.message}"
         end
       end
     end
@@ -235,41 +280,35 @@ module ActiveMatrix
     def check_agent_health
       @registry.find_each do |entry|
         agent = entry[:record]
-        thread = entry[:thread]
+        task = entry[:task]
 
-        # Check if thread is alive
-        unless thread&.alive?
-          logger.warn "Agent #{agent.name} thread died, restarting..."
+        # Check if task is alive
+        unless task&.alive?
+          logger.warn "Agent #{agent.name} task died, restarting..."
           @registry.unregister(agent)
           agent.encounter_error!
-          start_agent(agent) unless @shutdown
+          start_agent(agent) if @running
           next
         end
 
         # Check last activity
-        if agent.last_active_at && agent.last_active_at < 5.minutes.ago
-          logger.warn "Agent #{agent.name} seems inactive"
-          # Could implement additional health checks here
-        end
+        logger.warn "Agent #{agent.name} seems inactive" if agent.last_active_at && agent.last_active_at < 5.minutes.ago
       end
     end
 
     def cleanup_stale_data
-      # Clean up old conversation contexts
-      ConversationContext.cleanup_stale! if defined?(ConversationContext)
-
-      # Clean up expired memories
-      AgentMemory.cleanup_expired! if defined?(AgentMemory)
-      GlobalMemory.cleanup_expired! if defined?(GlobalMemory)
+      ActiveMatrix::ChatSession.cleanup_stale!
+      ActiveMatrix::AgentStore.cleanup_expired!
+      ActiveMatrix::KnowledgeBase.cleanup_expired!
     end
 
-    def setup_signal_handlers
-      %w[INT TERM].each do |signal|
-        Signal.trap(signal) do
-          Thread.new { stop_all }.join
-          exit # rubocop:disable Rails/Exit
-        end
-      end
+    def agent_attributes(agent)
+      OTEL_ATTRS.merge(
+        'agent.id' => agent.id,
+        'agent.name' => agent.name,
+        'agent.homeserver' => agent.homeserver,
+        'agent.bot_class' => agent.bot_class
+      )
     end
   end
 end

data/lib/active_matrix/agent_registry.rb

@@ -11,32 +11,33 @@ module ActiveMatrix
 
     def initialize
       @agents = Concurrent::Hash.new
-      @mutex = Mutex.new
     end
 
     # Register a running agent
     def register(agent_record, bot_instance)
-      @mutex.synchronize do
-        raise AgentAlreadyRunningError, "Agent #{agent_record.name} is already running" if @agents.key?(agent_record.id)
-
-        @agents[agent_record.id] = {
-          record: agent_record,
-          instance: bot_instance,
-          thread: Thread.current,
-          started_at: Time.current
-        }
+      raise AgentAlreadyRunningError, "Agent #{agent_record.name} is already running" if @agents.key?(agent_record.id)
 
-        logger.info "Registered agent: #{agent_record.name} (#{agent_record.id})"
-      end
+      @agents[agent_record.id] = {
+        record: agent_record,
+        instance: bot_instance,
+        task: nil,
+        started_at: Time.current
+      }
+
+      logger.info "Registered agent: #{agent_record.name} (#{agent_record.id})"
+    end
+
+    # Register an async task for an agent
+    def register_task(agent_record, task)
+      entry = @agents[agent_record.id]
+      entry[:task] = task if entry
     end
 
     # Unregister an agent
     def unregister(agent_record)
-      @mutex.synchronize do
-        entry = @agents.delete(agent_record.id)
-        logger.info "Unregistered agent: #{agent_record.name} (#{agent_record.id})" if entry
-        entry
-      end
+      entry = @agents.delete(agent_record.id)
+      logger.info "Unregistered agent: #{agent_record.name} (#{agent_record.id})" if entry
+      entry
     end
 
     # Get a running agent by ID
@@ -123,9 +124,7 @@ module ActiveMatrix
 
     # Clear all agents (used for testing)
     def clear!
-      @mutex.synchronize do
-        @agents.clear
-      end
+      @agents.clear
     end
 
     # Get health status of all agents
@@ -135,13 +134,18 @@ module ActiveMatrix
           id: id,
           name: entry[:record].name,
           state: entry[:record].state,
-          thread_alive: entry[:thread]&.alive?,
+          task_alive: entry[:task]&.alive?,
           uptime: Time.current - entry[:started_at],
           last_active: entry[:record].last_active_at
         }
       end
     end
 
+    # Iterate through all agents
+    def find_each(&)
+      @agents.values.each(&)
+    end
+
     private
 
     def by_name_pattern(pattern)