botiasloop 0.0.1

data/lib/botiasloop/channels.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Channels
+    # Registry for channel classes
+    #
+    # The Registry maintains a static mapping of channel identifiers to
+    # channel classes. It does not manage runtime instances - that is handled
+    # by ChannelsManager.
+    #
+    class Registry
+      attr_reader :channels
+
+      def initialize
+        @channels = {}
+      end
+
+      # Register a channel class
+      #
+      # @param channel_class [Class] Channel class inheriting from Base
+      def register(channel_class)
+        identifier = channel_class.channel_identifier
+        raise Error, "Channel class must define channel_name" unless identifier
+
+        @channels[identifier] = channel_class
+      end
+
+      # Deregister a channel by name
+      #
+      # @param name [Symbol] Channel identifier
+      def deregister(name)
+        @channels.delete(name)
+      end
+
+      # Get channel class by name
+      #
+      # @param name [Symbol] Channel identifier
+      # @return [Class, nil] Channel class or nil if not found
+      def [](name)
+        @channels[name]
+      end
+
+      # Get all registered channel names
+      #
+      # @return [Array<Symbol>] Channel identifiers
+      def names
+        @channels.keys
+      end
+
+      # Clear all registered channels
+      # Useful for testing to prevent state leakage
+      def clear
+        @channels.clear
+      end
+    end
+
+    # Singleton registry instance
+    #
+    # @return [Registry] The global channel registry
+    def self.registry
+      @registry ||= Registry.new
+    end
+  end
+end

data/lib/botiasloop/channels_manager.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Botiasloop
+  # Manages concurrent execution of multiple channels
+  #
+  # ChannelsManager provides a higher-level abstraction over the Channel Registry,
+  # handling the threading and lifecycle management required to run multiple
+  # channels simultaneously. Each channel runs in its own thread, allowing
+  # independent operation and error isolation.
+  #
+  # @example Basic usage
+  #   config = Botiasloop::Config.load
+  #   manager = Botiasloop::ChannelsManager.new(config)
+  #   manager.start_channels.wait
+  #
+  class ChannelsManager
+    # Time to wait for graceful shutdown before force-killing threads
+    SHUTDOWN_TIMEOUT = 5
+
+    # Channels that should not be auto-started (interactive channels)
+    EXCLUDED_CHANNELS = %i[cli].freeze
+
+    attr_reader :config
+
+    # Initialize a new ChannelsManager
+    #
+    # @param config [Config] Configuration instance
+    def initialize(config)
+      @config = config
+      @logger = Logger.new($stdout)
+      @threads = {}
+      @instances = {}
+      @mutex = Mutex.new
+      @running = false
+      @shutdown_requested = false
+    end
+
+    # Start all configured channels in separate threads
+    #
+    # Each channel is spawned in its own thread, allowing concurrent
+    # operation. Channels with missing configuration are skipped with
+    # a warning. Startup failures are logged but don't prevent other
+    # channels from starting.
+    #
+    # @return [ChannelsManager] self for method chaining
+    # @raise [Error] If channels are already running
+    def start_channels
+      @mutex.synchronize do
+        raise Error, "Channels are already running" if @running
+
+        @running = true
+        @shutdown_requested = false
+      end
+
+      setup_signal_handlers
+
+      registry = Channels.registry
+      registry.channels.each do |identifier, channel_class|
+        next if EXCLUDED_CHANNELS.include?(identifier)
+
+        begin
+          instance = channel_class.new(@config)
+        rescue Error => e
+          if e.message.match?(/Missing required configuration/)
+            @logger.warn "[ChannelsManager] Skipping #{identifier}: #{e.message}"
+            next
+          end
+          raise
+        end
+
+        thread = spawn_channel_thread(identifier, instance)
+        @mutex.synchronize do
+          @threads[identifier] = thread
+          @instances[identifier] = instance
+        end
+
+        @logger.info "[ChannelsManager] Started #{identifier} in thread #{thread.object_id}"
+      end
+
+      # Monitor threads for crashes
+      spawn_monitor_thread unless @threads.empty?
+
+      self
+    end
+
+    # Stop all running channels gracefully
+    #
+    # Sends stop signal to all channel instances and waits for threads
+    # to complete. Force-kills threads that don't stop within timeout.
+    #
+    # @return [void]
+    def stop_all
+      @mutex.synchronize do
+        return unless @running
+
+        @shutdown_requested = true
+        @running = false
+      end
+
+      @logger.info "[ChannelsManager] Stopping all channels..."
+
+      # Stop all channel instances
+      @instances.each do |identifier, instance|
+        instance.stop if instance.running?
+      rescue => e
+        @logger.error "[ChannelsManager] Error stopping #{identifier}: #{e.message}"
+      end
+
+      # Wait for threads to complete
+      @threads.each do |identifier, thread|
+        unless thread.join(SHUTDOWN_TIMEOUT)
+          @logger.warn "[ChannelsManager] Force-killing #{identifier} thread"
+          thread.kill
+        end
+      end
+
+      @mutex.synchronize do
+        @threads.clear
+        @instances.clear
+      end
+
+      @logger.info "[ChannelsManager] All channels stopped"
+    end
+
+    # Check if any channels are currently running
+    #
+    # @return [Boolean] True if any channel thread is alive
+    def running?
+      @mutex.synchronize do
+        return false unless @running
+
+        @threads.any? { |_, thread| thread.alive? }
+      end
+    end
+
+    # Get the number of active channel threads
+    #
+    # @return [Integer] Count of alive threads
+    def thread_count
+      @mutex.synchronize do
+        @threads.count { |_, thread| thread.alive? }
+      end
+    end
+
+    # Get a specific channel instance
+    #
+    # @param identifier [Symbol] Channel identifier
+    # @return [Base, nil] Channel instance or nil if not running
+    def instance(identifier)
+      @mutex.synchronize do
+        @instances[identifier]
+      end
+    end
+
+    # Get status information for a specific channel
+    #
+    # @param identifier [Symbol] Channel identifier
+    # @return [Hash, nil] Status hash or nil if channel not found
+    #   * :identifier [Symbol] Channel identifier
+    #   * :running [Boolean] Whether channel instance reports running
+    #   * :thread_alive [Boolean] Whether thread is alive
+    #   * :thread_id [Integer] Thread object ID
+    def channel_status(identifier)
+      @mutex.synchronize do
+        instance = @instances[identifier]
+        thread = @threads[identifier]
+
+        return nil unless instance
+
+        {
+          identifier: identifier,
+          running: instance.running?,
+          thread_alive: thread&.alive? || false,
+          thread_id: thread&.object_id
+        }
+      end
+    end
+
+    # Get status for all running channels
+    #
+    # @return [Hash{Symbol => Hash}] Map of channel identifier to status
+    def all_statuses
+      @mutex.synchronize do
+        @instances.transform_values do |instance|
+          thread = @threads[instance.class.channel_identifier]
+          {
+            identifier: instance.class.channel_identifier,
+            running: instance.running?,
+            thread_alive: thread&.alive? || false,
+            thread_id: thread&.object_id
+          }
+        end
+      end
+    end
+
+    # Block until all channels have stopped
+    #
+    # Useful for daemon mode where the main thread should wait.
+    # Returns immediately if no channels are running.
+    #
+    # @return [void]
+    def wait
+      return unless running?
+
+      # Wait for all threads to complete
+      loop do
+        sleep 0.1
+        break unless running?
+      end
+    end
+
+    private
+
+    # Spawn a thread to run a channel
+    #
+    # @param identifier [Symbol] Channel identifier
+    # @param instance [Base] Channel instance
+    # @return [Thread] The spawned thread
+    def spawn_channel_thread(identifier, instance)
+      Thread.new do
+        Thread.current.name = "botiasloop-#{identifier}"
+
+        begin
+          instance.start
+        rescue => e
+          @logger.error "[ChannelsManager] Channel #{identifier} crashed: #{e.message}"
+          @logger.error "[ChannelsManager] #{e.backtrace&.first(5)&.join("\n")}"
+        end
+      end
+    end
+
+    # Spawn a monitor thread to detect channel crashes
+    #
+    # @return [Thread] The monitor thread
+    def spawn_monitor_thread
+      Thread.new do
+        Thread.current.name = "botiasloop-monitor"
+
+        loop do
+          sleep 1.0
+
+          @mutex.synchronize do
+            break if @shutdown_requested
+
+            @threads.each do |identifier, thread|
+              next if thread.alive?
+
+              instance = @instances[identifier]
+              if instance&.running?
+                @logger.error "[ChannelsManager] Thread for #{identifier} died unexpectedly"
+                @instances.delete(identifier)
+                @threads.delete(identifier)
+              end
+            end
+
+            # Exit monitor if no more threads
+            break if @threads.empty?
+          end
+        end
+      end
+    end
+
+    # Set up signal handlers for graceful shutdown
+    #
+    # @return [void]
+    def setup_signal_handlers
+      # Store original handlers
+      @original_int_handler = Signal.trap("INT") { handle_shutdown_signal("INT") }
+      @original_term_handler = Signal.trap("TERM") { handle_shutdown_signal("TERM") }
+    end
+
+    # Handle shutdown signals
+    #
+    # Signals are handled in a separate thread to avoid
+    # limitations of trap context (no Mutex operations).
+    #
+    # @param signal [String] Signal name
+    # @return [void]
+    def handle_shutdown_signal(signal)
+      # Defer to separate thread to avoid trap context limitations
+      Thread.new do
+        @logger.info "[ChannelsManager] Received #{signal}, shutting down..."
+        stop_all
+
+        # Call original handler if it exists
+        case signal
+        when "INT"
+          @original_int_handler&.call if @original_int_handler.respond_to?(:call)
+        when "TERM"
+          @original_term_handler&.call if @original_term_handler.respond_to?(:call)
+        end
+
+        exit(0)
+      end.join
+    end
+  end
+end

data/lib/botiasloop/commands/archive.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Archive command - archives a conversation by label or UUID, or current conversation if no args
+    class Archive < Base
+      command :archive
+      description "Archive current conversation (no args) or a specific conversation by label/UUID"
+
+      # Execute the archive command
+      # Without args: archives current conversation and creates a new one
+      # With args: archives the specified conversation
+      #
+      # @param context [Context] Execution context
+      # @param args [String, nil] Label or UUID to archive (nil = archive current)
+      # @return [String] Command response with archived conversation details
+      def execute(context, args = nil)
+        identifier = args.to_s.strip
+        result = ConversationManager.archive(context.user_id, identifier.empty? ? nil : identifier)
+
+        if result[:new_conversation]
+          # Archived current and created new
+          context.conversation = result[:new_conversation]
+          format_archive_current_response(result[:archived], result[:new_conversation])
+        else
+          # Archived specific conversation
+          format_archive_response(result[:archived])
+        end
+      rescue Botiasloop::Error => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      def format_archive_response(conversation)
+        lines = ["**Conversation archived successfully**"]
+        lines << "- UUID: #{conversation.uuid}"
+
+        lines << if conversation.label?
+          "- Label: #{conversation.label}"
+        else
+          "- Label: (no label)"
+        end
+
+        count = conversation.message_count
+        lines << "- Messages: #{count}"
+
+        last = conversation.last_activity
+        lines << if last
+          "- Last activity: #{format_time_ago(last)}"
+        else
+          "- Last activity: no activity"
+        end
+
+        lines.join("\n")
+      end
+
+      def format_archive_current_response(archived, new_conversation)
+        lines = ["**Current conversation archived and new conversation started**"]
+        lines << ""
+        lines << "Archived:"
+        lines << "- UUID: #{archived.uuid}"
+
+        lines << if archived.label?
+          "- Label: #{archived.label}"
+        else
+          "- Label: (no label)"
+        end
+
+        count = archived.message_count
+        lines << "- Messages: #{count}"
+
+        last = archived.last_activity
+        lines << if last
+          "- Last activity: #{format_time_ago(last)}"
+        else
+          "- Last activity: no activity"
+        end
+
+        lines << ""
+        lines << "New conversation:"
+        lines << "- UUID: #{new_conversation.uuid}"
+        lines << "- Label: (no label)"
+
+        lines.join("\n")
+      end
+
+      def format_time_ago(timestamp)
+        time = Time.parse(timestamp)
+        now = Time.now.utc
+        diff = now - time
+
+        if diff < 60
+          "just now"
+        elsif diff < 3600
+          "#{Integer(diff / 60)} minutes ago"
+        elsif diff < 86_400
+          "#{Integer(diff / 3600)} hours ago"
+        elsif diff < 604_800
+          "#{Integer(diff / 86_400)} days ago"
+        else
+          time.strftime("%Y-%m-%d %H:%M UTC")
+        end
+      rescue ArgumentError
+        timestamp
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/base.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Base class for all slash commands
+    # Provides DSL for defining command metadata
+    class Base
+      class << self
+        # Get or set the command name
+        # Automatically registers the command when name is set
+        #
+        # @param name [Symbol, nil] Command name to set
+        # @return [Symbol, nil] The command name
+        def command(name = nil)
+          if name
+            @command_name = name
+            # Auto-register when command name is set
+            Botiasloop::Commands.registry.register(self)
+          end
+          @command_name
+        end
+
+        alias_method :command_name, :command
+
+        # Get or set the command description
+        #
+        # @param text [String, nil] Description text to set
+        # @return [String, nil] The command description
+        def description(text = nil)
+          if text
+            @description = text
+          end
+          @description
+        end
+
+        # Called when a subclass is defined
+        # No-op - registration happens when command() is called
+        def inherited(subclass)
+          super
+        end
+      end
+
+      # Execute the command
+      #
+      # @param context [Context] Execution context
+      # @param args [String, nil] Command arguments
+      # @return [String] Command response
+      # @raise [NotImplementedError] Subclass must implement
+      def execute(context, args = nil)
+        raise NotImplementedError, "Subclass must implement #execute"
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/compact.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Botiasloop
+  module Commands
+    # Compact command - compresses conversation by summarizing older messages
+    class Compact < Base
+      KEEP_RECENT = 5
+      MIN_MESSAGES = 10
+
+      command :compact
+      description "Compress conversation by summarizing older messages"
+
+      def execute(context, _args = nil)
+        conversation = context.conversation
+        config = context.config
+
+        messages = conversation.history
+
+        if messages.length < MIN_MESSAGES
+          return "Need at least #{MIN_MESSAGES} messages to compact. Current: #{messages.length}"
+        end
+
+        # Split messages: older ones to summarize, recent ones to keep
+        older_messages = messages[0...-KEEP_RECENT]
+        recent_messages = messages.last(KEEP_RECENT)
+
+        # Generate summary using LLM
+        summary = summarize_messages(older_messages, config)
+
+        # Replace conversation history
+        conversation.compact!(summary, recent_messages)
+
+        compacted_count = older_messages.length
+        summary_preview = (summary.length > 100) ? "#{summary[0..100]}..." : summary
+        "Conversation #{conversation.uuid} compacted.\n" \
+        "#{compacted_count} messages summarized, #{recent_messages.length} recent messages kept.\n" \
+        "Summary: #{summary_preview}"
+      end
+
+      private
+
+      def summarize_messages(messages, config)
+        chat = create_chat(config)
+
+        # Format messages for summarization
+        conversation_text = messages.map do |msg|
+          "#{msg[:role]}: #{msg[:content]}"
+        end.join("\n\n")
+
+        prompt = <<~PROMPT
+          Please summarize the following conversation, preserving key context, decisions, and facts. Be concise but comprehensive:
+
+          #{conversation_text}
+        PROMPT
+
+        chat.add_message(role: :user, content: prompt)
+        response = chat.complete
+
+        response.content
+      end
+
+      def create_chat(config)
+        summarize_config = config.commands["summarize"] || {}
+
+        if summarize_config["provider"] && summarize_config["model"]
+          # Use configured provider/model for summarization
+          RubyLLM.chat(model: summarize_config["model"])
+        else
+          # Fall back to default model
+          default_model = config.providers["openrouter"]["model"]
+          RubyLLM.chat(model: default_model)
+        end
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/context.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Context object passed to command executions
+    # Provides access to conversation, config, channel, and user info
+    class Context
+      # @return [Conversation] The current conversation
+      attr_accessor :conversation
+
+      # @return [Config] The bot configuration
+      attr_reader :config
+
+      # @return [Channels::Base, nil] The channel instance (nil in CLI)
+      attr_reader :channel
+
+      # @return [String, nil] The user/source identifier
+      attr_reader :user_id
+
+      # Initialize context
+      #
+      # @param conversation [Conversation] The current conversation
+      # @param config [Config] The bot configuration
+      # @param channel [Channels::Base, nil] The channel instance (nil in CLI)
+      # @param user_id [String, nil] The user/source identifier
+      def initialize(conversation:, config:, channel: nil, user_id: nil)
+        @conversation = conversation
+        @config = config
+        @channel = channel
+        @user_id = user_id
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/conversations.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Conversations command - lists all conversations
+    class Conversations < Base
+      command :conversations
+      description "List all conversations (use '/conversations archived' to list archived)"
+
+      # Execute the conversations command
+      # Lists non-archived conversations by default, or archived conversations when specified
+      # Sorted by last updated (most recent first)
+      #
+      # @param context [Context] Execution context
+      # @param args [String, nil] Arguments - 'archived' to list archived conversations
+      # @return [String] Formatted list of conversations
+      def execute(context, args = nil)
+        show_archived = args.to_s.strip.downcase == "archived"
+        conversations = ConversationManager.list_by_user(context.user_id, archived: show_archived)
+        current_uuid = ConversationManager.current_uuid_for(context.user_id)
+
+        lines = show_archived ? ["**Archived Conversations**"] : ["**Conversations**"]
+
+        if conversations.empty?
+          lines << (show_archived ? "No archived conversations found." : "No conversations found.")
+          return lines.join("\n")
+        end
+
+        conversations.each do |conv|
+          prefix = (conv[:uuid] == current_uuid) ? "[current] " : ""
+          label = conv[:label]
+          suffix = label ? " (#{label})" : ""
+          lines << "#{prefix}#{conv[:uuid]}#{suffix}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end