activematrix 0.0.5 → 0.0.8

data/lib/active_matrix/presence_manager.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module ActiveMatrix
+  # Manages Matrix presence for agents
+  # Provides automatic presence updates, wake hour awareness, and graceful shutdown
+  #
+  # @example Basic usage
+  #   presence = ActiveMatrix::PresenceManager.new(api: api, user_id: '@bot:example.com')
+  #   presence.start
+  #   presence.set_online(status_msg: 'Ready to help')
+  #   # ... later
+  #   presence.stop
+  #
+  # @example With wake hours
+  #   presence = ActiveMatrix::PresenceManager.new(
+  #     api: api,
+  #     user_id: '@bot:example.com',
+  #     wake_hour: 6,
+  #     sleep_hour: 22
+  #   )
+  #   presence.start # Will auto-set unavailable outside 6:00-22:00
+  #
+  class PresenceManager
+    include Instrumentation
+
+    attr_reader :user_id, :current_status, :current_message
+
+    # @param api [ActiveMatrix::Api] Matrix API instance
+    # @param user_id [String] The user ID to manage presence for
+    # @param refresh_interval [Integer] Seconds between presence refreshes (default: 300)
+    # @param wake_hour [Integer, nil] Hour (0-23) when bot becomes available (optional)
+    # @param sleep_hour [Integer, nil] Hour (0-23) when bot becomes unavailable (optional)
+    # @param timezone [String] Timezone for wake/sleep hours (default: system timezone)
+    def initialize(api:, user_id:, refresh_interval: 300, wake_hour: nil, sleep_hour: nil, timezone: nil)
+      @api = api
+      @user_id = user_id
+      @refresh_interval = refresh_interval
+      @wake_hour = wake_hour
+      @sleep_hour = sleep_hour
+      @timezone = timezone
+
+      @current_status = 'offline'
+      @current_message = nil
+      @running = Concurrent::AtomicBoolean.new(false)
+      @task = nil
+      @mutex = Mutex.new
+    end
+
+    # Start the presence manager
+    # Begins periodic presence updates
+    def start
+      return if @running.true?
+
+      @running.make_true
+      schedule_refresh
+      ActiveMatrix.logger.info("PresenceManager started for #{@user_id}")
+    end
+
+    # Stop the presence manager
+    # Sets presence to offline and stops refresh loop
+    def stop
+      return unless @running.true?
+
+      @running.make_false
+      @task&.cancel
+      @task = nil
+
+      # Set offline on shutdown
+      set_offline
+      ActiveMatrix.logger.info("PresenceManager stopped for #{@user_id}")
+    end
+
+    # Set presence to online
+    #
+    # @param status_msg [String, nil] Optional status message
+    def set_online(status_msg: nil)
+      set_presence('online', status_msg)
+    end
+
+    # Set presence to unavailable
+    #
+    # @param status_msg [String, nil] Optional status message
+    def set_unavailable(status_msg: nil)
+      set_presence('unavailable', status_msg)
+    end
+
+    # Set presence to offline
+    def set_offline
+      set_presence('offline', nil)
+    end
+
+    # Check if currently within wake hours
+    #
+    # @return [Boolean] true if within wake hours or no wake hours configured
+    def within_wake_hours?
+      return true if @wake_hour.nil? || @sleep_hour.nil?
+
+      current_hour = current_time.hour
+
+      if @wake_hour < @sleep_hour
+        # Normal case: wake 6, sleep 22 -> active from 6:00 to 21:59
+        current_hour >= @wake_hour && current_hour < @sleep_hour
+      else
+        # Overnight case: wake 22, sleep 6 -> active from 22:00 to 5:59
+        current_hour >= @wake_hour || current_hour < @sleep_hour
+      end
+    end
+
+    # Get current presence status from server
+    #
+    # @return [Hash] Presence status including :presence and :status_msg
+    def get_status
+      instrument_operation(:get_presence, user_id: @user_id) do
+        @api.get_presence_status(@user_id)
+      end
+    rescue StandardError => e
+      ActiveMatrix.logger.warn("Failed to get presence for #{@user_id}: #{e.message}")
+      { presence: @current_status, status_msg: @current_message }
+    end
+
+    private
+
+    def agent_id
+      @user_id
+    end
+
+    def set_presence(status, message)
+      @mutex.synchronize do
+        # Check wake hours before setting online
+        actual_status = if status == 'online' && !within_wake_hours?
+                          'unavailable'
+                        else
+                          status
+                        end
+
+        instrument_operation(:set_presence, user_id: @user_id, status: actual_status) do
+          @api.set_presence_status(@user_id, actual_status, message: message)
+        end
+
+        @current_status = actual_status
+        @current_message = message
+
+        ActiveMatrix.logger.debug("Presence set to #{actual_status} for #{@user_id}")
+      end
+    rescue StandardError => e
+      ActiveMatrix.logger.error("Failed to set presence for #{@user_id}: #{e.message}")
+    end
+
+    def schedule_refresh
+      return unless @running.true?
+
+      @task = Concurrent::ScheduledTask.execute(@refresh_interval) do
+        refresh_presence
+        schedule_refresh
+      end
+    end
+
+    def refresh_presence
+      return unless @running.true?
+
+      # Re-check wake hours and update if needed
+      if within_wake_hours?
+        set_presence(@current_status == 'offline' ? 'online' : @current_status, @current_message)
+      else
+        set_presence('unavailable', @current_message)
+      end
+    rescue StandardError => e
+      ActiveMatrix.logger.error("Error refreshing presence: #{e.message}")
+    end
+
+    def current_time
+      if @timezone && defined?(ActiveSupport::TimeZone)
+        ActiveSupport::TimeZone[@timezone]&.now || Time.current
+      else
+        Time.current
+      end
+    end
+  end
+end

data/lib/active_matrix/railtie.rb

@@ -4,9 +4,17 @@ require 'rails/railtie'
 
 module ActiveMatrix
   class Railtie < Rails::Railtie
+    Rails.logger.debug 'ActiveMatrix::Railtie: Loading...'
+
     initializer 'activematrix.configure_rails_initialization' do
+      Rails.logger.debug 'ActiveMatrix::Railtie: Initializer running'
       # Configure Rails.logger as the default logger
       ActiveMatrix.logger = Rails.logger
+      Rails.logger.debug 'ActiveMatrix::Railtie: Logger configured'
+
+      # Debug autoload paths
+      Rails.logger.debug { "ActiveMatrix::Railtie: Autoload paths = #{Rails.application.config.autoload_paths}" }
+      Rails.logger.debug { "ActiveMatrix::Railtie: Eager load paths = #{Rails.application.config.eager_load_paths}" }
     end
   end
 end

data/lib/active_matrix/telemetry.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  # OpenTelemetry integration for ActiveMatrix
+  #
+  # Provides distributed tracing for:
+  # - Agent lifecycle (connect, disconnect, error)
+  # - Message handling
+  # - Room operations
+  # - Matrix API calls
+  #
+  # @example Enable with OTLP exporter
+  #   ENV['OTEL_TRACES_EXPORTER'] = 'otlp'
+  #   ENV['OTEL_SERVICE_NAME'] = 'activematrix'
+  #   ActiveMatrix::Telemetry.configure!
+  #
+  # @example Enable with console exporter for debugging
+  #   ActiveMatrix::Telemetry.configure!(exporter: :console)
+  #
+  module Telemetry
+    TRACER_NAME = 'activematrix'
+    TRACER_VERSION = ActiveMatrix::VERSION
+
+    class << self
+      # @return [Boolean] whether OpenTelemetry is available
+      def available?
+        @available ||= begin
+          require 'opentelemetry/sdk'
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      # @return [Boolean] whether telemetry has been configured
+      def configured?
+        @configured ||= false
+      end
+
+      # Configure OpenTelemetry SDK for ActiveMatrix
+      #
+      # @param exporter [Symbol, nil] :console, :otlp, or nil for env-based config
+      # @param service_name [String] service name for traces
+      def configure!(exporter: nil, service_name: 'activematrix')
+        return false unless available?
+        return true if configured?
+
+        require 'opentelemetry/sdk'
+
+        case exporter
+        when :console
+          require 'opentelemetry/sdk'
+          OpenTelemetry::SDK.configure do |c|
+            c.service_name = service_name
+            c.add_span_processor(
+              OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+                OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+              )
+            )
+          end
+        when :otlp
+          require 'opentelemetry/exporter/otlp'
+          ENV['OTEL_SERVICE_NAME'] ||= service_name
+          OpenTelemetry::SDK.configure
+        else
+          # Use environment variables
+          ENV['OTEL_SERVICE_NAME'] ||= service_name
+          OpenTelemetry::SDK.configure
+        end
+
+        @configured = true
+      end
+
+      # Get the ActiveMatrix tracer
+      #
+      # @return [OpenTelemetry::Trace::Tracer, NullTracer]
+      def tracer
+        return NullTracer.instance unless configured?
+
+        OpenTelemetry.tracer_provider.tracer(TRACER_NAME, TRACER_VERSION)
+      end
+
+      # Trace a block of code
+      #
+      # @param name [String] span name
+      # @param attributes [Hash] span attributes
+      # @yield [span] the current span
+      def trace(name, attributes: {}, kind: :internal, &)
+        return yield(NullSpan.instance) unless configured?
+
+        tracer.in_span(name, attributes: attributes, kind: kind, &)
+      end
+
+      # Record an exception on the current span
+      #
+      # @param exception [Exception]
+      # @param attributes [Hash] additional attributes
+      def record_exception(exception, attributes: {})
+        return unless configured?
+
+        span = OpenTelemetry::Trace.current_span
+        span.record_exception(exception, attributes: attributes)
+        span.status = OpenTelemetry::Trace::Status.error(exception.message)
+      end
+
+      # Shutdown the tracer provider
+      def shutdown
+        return unless configured?
+
+        OpenTelemetry.tracer_provider.shutdown
+        @configured = false
+      end
+    end
+
+    # Null tracer for when OTel is not available
+    class NullTracer
+      include Singleton
+
+      def in_span(_name, **_opts)
+        yield NullSpan.instance
+      end
+    end
+
+    # Null span for when OTel is not available
+    class NullSpan
+      include Singleton
+
+      def set_attribute(_key, _value); end
+      def add_event(_name, **_opts); end
+      def record_exception(_exception, **_opts); end
+      def status=(_status); end
+    end
+  end
+end

data/lib/active_matrix/version.rb

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

data/lib/active_matrix.rb

@@ -5,12 +5,9 @@ require_relative 'active_matrix/version'
 
 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/time/zones'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/object/blank'
+require 'active_record'
+require 'active_job'
+require 'state_machines-activerecord'
 
 module ActiveMatrix
   # Configuration
@@ -31,7 +28,9 @@ module ActiveMatrix
                   :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
+                  :agent_log_level, :log_agent_events,
+                  # Daemon settings
+                  :daemon_workers, :probe_port, :probe_host, :shutdown_timeout
 
     def initialize
       # Set defaults
@@ -47,6 +46,11 @@ module ActiveMatrix
       @client_idle_timeout = 300 # 5 minutes
       @agent_log_level = :info
       @log_agent_events = false
+      # Daemon defaults
+      @daemon_workers = 1
+      @probe_port = 3042
+      @probe_host = '127.0.0.1'
+      @shutdown_timeout = 30
     end
   end
 
@@ -82,11 +86,14 @@ module ActiveMatrix
   # Ignore directories and files that shouldn't be autoloaded
   Loader.ignore("#{__dir__}/generators")
   Loader.ignore("#{__dir__}/activematrix.rb")
-  
-  # Ignore files that don't follow Zeitwerk naming conventions
+
+  # Ignore files that don't follow Zeitwerk naming conventions or are standalone
   Loader.ignore("#{__dir__}/active_matrix/errors.rb")
   Loader.ignore("#{__dir__}/active_matrix/events.rb")
   Loader.ignore("#{__dir__}/active_matrix/uri_module.rb")
+  Loader.ignore("#{__dir__}/active_matrix/cli.rb")
+  Loader.ignore("#{__dir__}/active_matrix/daemon.rb")
+  Loader.ignore("#{__dir__}/active_matrix/daemon")
 
   # Configure inflections for special cases
   Loader.inflector.inflect(
@@ -107,6 +114,6 @@ module ActiveMatrix
   require_relative 'active_matrix/events'
   require_relative 'active_matrix/uri_module'
 
-  # Load Railtie for Rails integration
-  require 'active_matrix/railtie' if defined?(Rails::Railtie)
+  # Load Engine for Rails integration
+  require 'active_matrix/engine'
 end

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

@@ -1,44 +1,25 @@
 # 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'
+      desc 'Installs ActiveMatrix initializer and copies migrations'
 
-      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'
+      def copy_migrations
+        rails_command 'active_matrix:install:migrations', inline: true
       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

@@ -2,6 +2,9 @@
 
 ActiveMatrix Multi-Agent System has been installed!
 
+Requirements:
+- PostgreSQL 18+ (for UUIDv7 support)
+
 Next steps:
 
 1. Run migrations:
@@ -11,7 +14,7 @@ Next steps:
    rails generate active_matrix:bot MyFirstBot
 
 3. Configure your agents in the Rails console:
-   agent = MatrixAgent.create!(
+   agent = ActiveMatrix::Agent.create!(
      name: 'captain',
      homeserver: 'https://matrix.org',
      username: 'captain_bot',
@@ -25,6 +28,6 @@ Next steps:
 Or start individual agents:
    ActiveMatrix::AgentManager.instance.start_agent(agent)
 
-For more information, visit: https://github.com/seuros/agent_smith
+For more information, visit: https://github.com/seuros/activematrix
 
 ===============================================================================