activematrix 0.0.5 → 0.0.8

data/lib/active_matrix/api.rb

@@ -10,7 +10,7 @@ module ActiveMatrix
     extend ActiveMatrix::Extensions
     include ActiveMatrix::Logging
 
-    USER_AGENT = "Ruby Matrix SDK v#{ActiveMatrix::VERSION}".freeze
+    USER_AGENT = "ActiveMatrix v#{ActiveMatrix::VERSION}".freeze
     DEFAULT_HEADERS = {
       'accept' => 'application/json',
       'user-agent' => USER_AGENT
@@ -287,7 +287,7 @@ module ActiveMatrix
       end
 
       failures = 0
-      loop do
+      loop do # rubocop:disable Metrics/BlockLength
         raise MatrixConnectionError, "Server still too busy to handle request after #{failures} attempts, try again later" if failures >= 10
 
         req_id = ('A'..'Z').to_a.sample(4).join
@@ -343,6 +343,12 @@ module ActiveMatrix
         end
         raise MatrixRequestError.new_by_code(data, response.code) if data
 
+        # For 4xx errors without JSON body, construct a synthetic error
+        if response.code.to_i >= 400 && response.code.to_i < 500
+          synthetic_error = { errcode: 'M_UNKNOWN', error: "HTTP #{response.code} #{response.message}" }
+          raise MatrixRequestError.new_by_code(synthetic_error, response.code)
+        end
+
         raise MatrixConnectionError.class_by_code(response.code), response
       end
     end

data/lib/active_matrix/async_query.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  # Helper methods for async ActiveRecord queries (Rails 8.0+)
+  module AsyncQuery
+    module_function
+
+    # Load records asynchronously
+    # @param relation [ActiveRecord::Relation] The relation to load
+    # @return [Array] The loaded records
+    def load_async(relation)
+      relation.load_async.to_a
+    end
+
+    # Count records asynchronously
+    # @param relation [ActiveRecord::Relation] The relation to count
+    # @return [Integer] The count
+    def async_count(relation)
+      relation.async_count.value
+    end
+
+    # Sum column asynchronously
+    # @param relation [ActiveRecord::Relation] The relation
+    # @param column [Symbol] The column to sum
+    # @return [Numeric] The sum
+    def async_sum(relation, column)
+      relation.async_sum(column).value
+    end
+
+    # Pluck columns asynchronously
+    # @param relation [ActiveRecord::Relation] The relation
+    # @param columns [Array<Symbol>] The columns to pluck
+    # @return [Array] The plucked values
+    def async_pluck(relation, *columns)
+      relation.async_pluck(*columns).value
+    end
+
+    # Check existence asynchronously
+    # @param relation [ActiveRecord::Relation] The relation
+    # @return [Boolean] Whether records exist
+    def async_exists?(relation)
+      relation.async_count.value.positive?
+    end
+
+    # Execute multiple async queries in parallel and wait for all results
+    # @param queries [Hash<Symbol, Proc>] Named queries to execute
+    # @return [Hash<Symbol, Object>] Results keyed by query name
+    # @example
+    #   results = AsyncQuery.parallel(
+    #     agents: -> { MatrixAgent.where(state: :online).load_async },
+    #     count: -> { MatrixAgent.async_count }
+    #   )
+    def parallel(**queries)
+      promises = queries.transform_values(&:call)
+      promises.transform_values { |result| result.respond_to?(:value) ? result.value : result }
+    end
+  end
+end

data/lib/active_matrix/bot/base.rb

@@ -377,7 +377,7 @@ module ActiveMatrix::Bot
         if settings.store_sync_token
           begin
             active_bot.client.api.set_account_data(
-              active_bot.client.mxid, "dev.ananace.ruby-sdk.#{settings.bot_name}",
+              active_bot.client.mxid, "com.seuros.active_matrix.#{settings.bot_name}",
               { sync_token: active_bot.client.sync_token }
             )
           rescue StandardError => e
@@ -466,7 +466,7 @@ module ActiveMatrix::Bot
           bot.client.instance_variable_set(:@next_batch, settings.sync_token)
         elsif settings.store_sync_token?
           begin
-            data = bot.client.api.get_account_data(bot.client.mxid, "dev.ananace.ruby-sdk.#{bot_name}")
+            data = bot.client.api.get_account_data(bot.client.mxid, "com.seuros.active_matrix.#{bot_name}")
             bot.client.sync_token = data[:sync_token]
           rescue ActiveMatrix::MatrixNotFoundError
             # Valid
@@ -479,7 +479,7 @@ module ActiveMatrix::Bot
 
         bot.client.start_listener_thread
 
-        bot.client.instance_variable_get(:@sync_thread).join
+        bot.client.sync_thread&.join
       rescue Interrupt
         # Happens when killed
       rescue StandardError => e

data/lib/active_matrix/bot/builtin_commands.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  module Bot
+    # Built-in commands that can be included in bot classes
+    #
+    # @example Include in a bot
+    #   class MyBot < ActiveMatrix::Bot::Base
+    #     include ActiveMatrix::Bot::BuiltinCommands
+    #   end
+    #
+    module BuiltinCommands
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.register_builtin_commands
+      end
+
+      module ClassMethods
+        def register_builtin_commands
+          # Ping command - connectivity test
+          command(
+            :ping,
+            desc: 'Test bot connectivity and response time'
+          ) do
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            response_parts = [
+              '**Pong!**',
+              '',
+              'Bot is online and responding',
+              "Server time: #{Time.current.strftime('%Y-%m-%d %H:%M:%S %Z')}"
+            ]
+
+            end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            response_time_ms = ((end_time - start_time) * 1000).round(2)
+            response_parts.insert(2, "Response time: #{response_time_ms}ms")
+
+            room.send_notice(response_parts.join("\n"))
+          end
+
+          # Version command - show bot version
+          command(
+            :version,
+            desc: 'Show bot version information'
+          ) do
+            response_parts = [
+              '**Version Information**',
+              '',
+              "ActiveMatrix: #{ActiveMatrix::VERSION}",
+              "Ruby: #{RUBY_VERSION}",
+              "Platform: #{RUBY_PLATFORM}"
+            ]
+
+            # Add application version if available
+            response_parts << "Application: #{Rails.application.version}" if defined?(Rails) && Rails.application.respond_to?(:version)
+
+            room.send_notice(response_parts.join("\n"))
+          end
+
+          # Status command - show bot status
+          command(
+            :status,
+            desc: 'Show bot status and health information'
+          ) do
+            response_parts = [
+              '**Bot Status**',
+              '',
+              'State: Online',
+              "Uptime: #{format_uptime}",
+              "User ID: #{client.mxid}",
+              "Homeserver: #{client.api.homeserver}"
+            ]
+
+            # Add room count if available
+            if client.respond_to?(:rooms)
+              room_count = client.rooms.size
+              response_parts << "Joined rooms: #{room_count}"
+            end
+
+            # Add metrics if available
+            if defined?(ActiveMatrix::Metrics)
+              metrics = ActiveMatrix::Metrics.instance.get_health_summary
+              if metrics[:total_operations].positive?
+                response_parts += [
+                  '',
+                  '**Metrics**',
+                  "Total operations: #{metrics[:total_operations]}",
+                  "Success rate: #{metrics[:overall_success_rate]}%"
+                ]
+              end
+            end
+
+            room.send_notice(response_parts.join("\n"))
+          end
+
+          # Time command - show current time
+          command(
+            :time,
+            desc: 'Show current time in specified timezone',
+            notes: 'Usage: !time [TIMEZONE]. Examples: !time UTC, !time America/New_York'
+          ) do |timezone = nil|
+            time = if timezone && defined?(ActiveSupport::TimeZone)
+                     tz = ActiveSupport::TimeZone[timezone]
+                     if tz
+                       tz.now
+                     else
+                       room.send_notice("Unknown timezone: #{timezone}. Using server time.")
+                       Time.current
+                     end
+                   else
+                     Time.current
+                   end
+
+            formatted = time.strftime('%Y-%m-%d %H:%M:%S %Z')
+            unix_timestamp = time.to_i
+
+            response_parts = [
+              '**Current Time**',
+              '',
+              formatted,
+              "Unix timestamp: #{unix_timestamp}"
+            ]
+
+            room.send_notice(response_parts.join("\n"))
+          end
+
+          # Echo command - echo back message
+          command(
+            :echo,
+            desc: 'Echo back the provided message'
+          ) do |message = nil|
+            if message.nil? || message.strip.empty?
+              room.send_notice('Nothing to echo. Usage: !echo <message>')
+            else
+              room.send_text(message)
+            end
+          end
+
+          # Rooms command - list joined rooms (admin only)
+          command(
+            :rooms,
+            desc: 'List joined rooms',
+            only: :admin
+          ) do
+            rooms_list = client.rooms.map do |r|
+              name = r.display_name || r.id
+              "- #{name}"
+            end
+
+            if rooms_list.empty?
+              room.send_notice('Not joined to any rooms.')
+            else
+              response = [
+                "**Joined Rooms** (#{rooms_list.size})",
+                '',
+                *rooms_list.first(20)
+              ]
+
+              response << "... and #{rooms_list.size - 20} more" if rooms_list.size > 20
+
+              room.send_notice(response.join("\n"))
+            end
+          end
+        end
+      end
+
+      private
+
+      def format_uptime
+        return 'Unknown' unless defined?(@start_time)
+
+        seconds = (Time.current - @start_time).to_i
+        days = seconds / 86_400
+        hours = (seconds % 86_400) / 3600
+        minutes = (seconds % 3600) / 60
+        secs = seconds % 60
+
+        parts = []
+        parts << "#{days}d" if days.positive?
+        parts << "#{hours}h" if hours.positive?
+        parts << "#{minutes}m" if minutes.positive?
+        parts << "#{secs}s" if secs.positive? || parts.empty?
+
+        parts.join(' ')
+      end
+    end
+  end
+end

data/lib/active_matrix/bot/command_parser.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module ActiveMatrix
+  module Bot
+    # Parses command arguments with support for flags and quoted strings
+    #
+    # @example Basic parsing
+    #   parser = CommandParser.new('search "hello world" --verbose')
+    #   parser.args        # => ["search", "hello world"]
+    #   parser.flags       # => { "verbose" => true }
+    #
+    # @example With key-value flags
+    #   parser = CommandParser.new('greet --name=Alice --formal')
+    #   parser.positional_args  # => []
+    #   parser.flags            # => { "name" => "Alice", "formal" => true }
+    #
+    class CommandParser
+      attr_reader :raw_input, :command_name, :args, :raw_args
+
+      # Command prefixes recognized by the parser
+      COMMAND_PREFIXES = ['/', '!'].freeze
+
+      # @param input [String] Raw command input
+      # @param prefixes [Array<String>] Command prefixes to recognize
+      def initialize(input, prefixes: COMMAND_PREFIXES)
+        @raw_input = input.to_s.strip
+        @prefixes = prefixes
+        @command_name = nil
+        @args = []
+        @raw_args = ''
+        @parsed_flags = nil
+        parse!
+      end
+
+      # Check if input is a valid command (has prefix and command name)
+      #
+      # @return [Boolean]
+      def command?
+        !@command_name.nil? && @prefixes.any? { |prefix| @raw_input.start_with?(prefix) }
+      end
+
+      # Get the prefix used in the command
+      #
+      # @return [String, nil]
+      def prefix
+        @prefixes.find { |p| @raw_input.start_with?(p) }
+      end
+
+      # Parse flags and positional arguments
+      #
+      # @return [Hash] Hash with :flags and :args keys
+      def parse_flags
+        @parse_flags ||= begin
+          flags = {}
+          positional = []
+
+          @args.each do |arg|
+            case arg
+            when /\A--([^=]+)=(.+)\z/
+              # --key=value format
+              flags[Regexp.last_match(1)] = Regexp.last_match(2)
+            when /\A--(.+)\z/
+              # --flag format (boolean)
+              flags[Regexp.last_match(1)] = true
+            when /\A-([a-zA-Z]+)\z/
+              # Short flags like -v, -abc (multiple)
+              Regexp.last_match(1).chars.each { |c| flags[c] = true }
+            else
+              positional << arg
+            end
+          end
+
+          { flags: flags, args: positional }
+        end
+      end
+
+      # Get only positional arguments (no flags)
+      #
+      # @return [Array<String>]
+      def positional_args
+        parse_flags[:args]
+      end
+
+      # Get only flag arguments
+      #
+      # @return [Hash<String, Object>]
+      def flags
+        parse_flags[:flags]
+      end
+
+      # Check if a specific flag is set
+      #
+      # @param name [String] Flag name (without dashes)
+      # @return [Boolean]
+      def flag?(name)
+        flags.key?(name.to_s)
+      end
+
+      # Get a flag value
+      #
+      # @param name [String] Flag name
+      # @param default [Object] Default value if flag not set
+      # @return [Object]
+      def flag(name, default = nil)
+        flags.fetch(name.to_s, default)
+      end
+
+      # Formatted command string
+      #
+      # @return [String]
+      def formatted_command
+        return '' unless command?
+
+        [@command_name, *@args].join(' ')
+      end
+
+      private
+
+      def parse!
+        # Check if input starts with a valid prefix
+        found_prefix = @prefixes.find { |p| @raw_input.start_with?(p) }
+        return unless found_prefix
+
+        # Remove prefix
+        content = @raw_input[found_prefix.length..].strip
+        return if content.empty?
+
+        # Parse respecting quoted strings
+        parts = parse_with_quotes(content)
+        return if parts.empty?
+
+        @command_name = parts.first.downcase
+        @args = parts[1..] || []
+        @raw_args = @args.join(' ')
+      end
+
+      def parse_with_quotes(input)
+        parts = []
+        current = +''
+        in_quotes = false
+        quote_char = nil
+
+        input.each_char do |char|
+          case char
+          when '"', "'"
+            if in_quotes && char == quote_char
+              # End of quoted section
+              in_quotes = false
+              quote_char = nil
+            elsif !in_quotes
+              # Start of quoted section
+              in_quotes = true
+              quote_char = char
+            else
+              # Different quote inside quotes, treat as literal
+              current << char
+            end
+          when ' ', "\t"
+            if in_quotes
+              current << char
+            elsif current.length.positive?
+              parts << current
+              current = +''
+            end
+          else
+            current << char
+          end
+        end
+
+        parts << current if current.length.positive?
+        parts
+      end
+    end
+  end
+end