botiasloop 0.0.1 → 0.0.7

data/lib/botiasloop/channels/telegram.rb

@@ -5,6 +5,10 @@ require "json"
 require "fileutils"
 require "redcarpet"
 
+# Regex patterns for markdown parsing
+CODE_BLOCK_REGEX = /```\w*\n?([\s\S]*?)```/
+INLINE_CODE_REGEX = /`([^`]+)`/
+
 module Botiasloop
   module Channels
     class Telegram < Base
@@ -13,9 +17,8 @@ module Botiasloop
 
       # Initialize Telegram channel
       #
-      # @param config [Config] Configuration instance
       # @raise [Error] If bot_token is not configured
-      def initialize(config)
+      def initialize
         super
         cfg = channel_config
         @bot_token = cfg["bot_token"]
@@ -25,13 +28,13 @@ module Botiasloop
       end
 
       # Start the Telegram bot and listen for messages
-      def start
+      def start_listening
         if @allowed_users.empty?
-          @logger.warn "[Telegram] No allowed_users configured. No messages will be processed."
-          @logger.warn "[Telegram] Add usernames to telegram.allowed_users in config."
+          Logger.warn "[Telegram] No allowed_users configured. No messages will be processed."
+          Logger.warn "[Telegram] Add usernames to telegram.allowed_users in config."
         end
 
-        @logger.info "[Telegram] Starting bot..."
+        Logger.info "[Telegram] Starting bot..."
 
         @bot = ::Telegram::Bot::Client.new(@bot_token)
         register_bot_commands
@@ -45,15 +48,15 @@ module Botiasloop
           end
         end
       rescue Interrupt
-        @logger.info "[Telegram] Shutting down..."
+        Logger.info "[Telegram] Shutting down..."
       end
 
       # Stop the Telegram bot
       #
       # Interrupts the thread running the bot to gracefully exit
       # the blocking listen loop.
-      def stop
-        @logger.info "[Telegram] Stopping bot..."
+      def stop_listening
+        Logger.info "[Telegram] Stopping bot..."
 
         return unless @thread_id
 
@@ -83,7 +86,7 @@ module Botiasloop
       # @param source_id [String] Source identifier (chat_id)
       # @param raw_message [Telegram::Bot::Types::Message] Telegram message
       # @return [String, nil] Username from message
-      def extract_user_id(source_id, raw_message)
+      def extract_user_id(_source_id, raw_message)
         raw_message.from&.username
       end
 
@@ -93,8 +96,8 @@ module Botiasloop
       # @param user_id [String] Username
       # @param content [String] Message text
       # @param raw_message [Telegram::Bot::Types::Message] Telegram message
-      def before_process(source_id, user_id, content, raw_message)
-        @logger.info "[Telegram] Message from @#{user_id}: #{content}"
+      def before_process(_source_id, user_id, content, _raw_message)
+        Logger.info "[Telegram] Message from @#{user_id}: #{content}"
       end
 
       # Log successful response after processing
@@ -103,8 +106,8 @@ module Botiasloop
       # @param user_id [String] Username
       # @param response [String] Response content
       # @param raw_message [Telegram::Bot::Types::Message] Telegram message
-      def after_process(source_id, user_id, response, raw_message)
-        @logger.info "[Telegram] Response sent to @#{user_id}"
+      def after_process(_source_id, user_id, _response, _raw_message)
+        Logger.info "[Telegram] Response sent to @#{user_id}"
       end
 
       # Handle unauthorized access with specific logging
@@ -112,8 +115,8 @@ module Botiasloop
       # @param source_id [String] Source identifier
       # @param user_id [String] Username that was denied
       # @param raw_message [Telegram::Bot::Types::Message] Telegram message
-      def handle_unauthorized(source_id, user_id, raw_message)
-        @logger.warn "[Telegram] Ignored message from unauthorized user @#{user_id} (chat_id: #{source_id})"
+      def handle_unauthorized(source_id, user_id, _raw_message)
+        Logger.warn "[Telegram] Ignored message from unauthorized user @#{user_id} (chat_id: #{source_id})"
       end
 
       # Handle errors by logging only (don't notify user)
@@ -122,8 +125,8 @@ module Botiasloop
       # @param user_id [String] Username
       # @param error [Exception] The error that occurred
       # @param raw_message [Telegram::Bot::Types::Message] Telegram message
-      def handle_error(source_id, user_id, error, raw_message)
-        @logger.error "[Telegram] Error processing message: #{error.message}"
+      def handle_error(_source_id, _user_id, error, _raw_message)
+        Logger.error "[Telegram] Error processing message: #{error.message}"
       end
 
       # Check if username is in allowed list
@@ -136,11 +139,13 @@ module Botiasloop
         @allowed_users.include?(username)
       end
 
-      # Deliver a formatted response to Telegram
+      # Deliver a formatted message to Telegram
       #
       # @param chat_id [String] Telegram chat ID (as string)
       # @param formatted_content [String] Formatted message content
-      def deliver_response(chat_id, formatted_content)
+      def deliver_message(chat_id, formatted_content)
+        return if formatted_content.nil? || formatted_content.empty?
+
         @bot.api.send_message(
           chat_id: chat_id.to_i,
           text: formatted_content,
@@ -148,11 +153,11 @@ module Botiasloop
         )
       end
 
-      # Format response for Telegram
+      # Format message for Telegram
       #
-      # @param content [String] Raw response content
+      # @param content [String] Raw message content
       # @return [String] Telegram-compatible HTML
-      def format_response(content)
+      def format_message(content)
         return "" if content.nil? || content.empty?
 
         to_telegram_html(content)
@@ -170,24 +175,64 @@ module Botiasloop
         end
 
         @bot.api.set_my_commands(commands: commands)
-        @logger.info "[Telegram] Registered #{commands.length} bot commands"
+        Logger.info "[Telegram] Registered #{commands.length} bot commands"
       rescue => e
-        @logger.warn "[Telegram] Failed to register bot commands: #{e.message}"
+        Logger.warn "[Telegram] Failed to register bot commands: #{e.message}"
       end
 
       # Convert Markdown to Telegram-compatible HTML
       #
+      # Extracts and protects code blocks before other processing,
+      # then restores them with proper HTML tags.
+      #
       # @param markdown [String] Markdown text
       # @return [String] Telegram-compatible HTML
       def to_telegram_html(markdown)
-        # Configure Redcarpet renderer for Telegram-compatible HTML
+        # Step 1: Extract and protect code blocks (fenced ```code```)
+        code_blocks = []
+        text = markdown.gsub(CODE_BLOCK_REGEX) do |_|
+          code_blocks << Regexp.last_match(1)
+          "\x00CB#{code_blocks.length - 1}\x00"
+        end
+
+        # Step 2: Extract and protect inline code (`code`)
+        inline_codes = []
+        text = text.gsub(INLINE_CODE_REGEX) do |_|
+          inline_codes << Regexp.last_match(1)
+          "\x00IC#{inline_codes.length - 1}\x00"
+        end
+
+        # Step 3: Convert remaining markdown to HTML
+        html = markdown_to_html(text)
+
+        # Step 4: Restore inline code with <code> tags
+        inline_codes.each_with_index do |code, i|
+          escaped = escape_html(code)
+          html = html.gsub("\x00IC#{i}\x00", "<code>#{escaped}</code>")
+        end
+
+        # Step 5: Restore code blocks with <pre><code> tags
+        code_blocks.each_with_index do |code, i|
+          escaped = escape_html(code)
+          html = html.gsub("\x00CB#{i}\x00", "<pre><code>#{escaped}</code></pre>")
+        end
+
+        html
+      end
+
+      # Convert markdown text to HTML using Redcarpet
+      #
+      # @param text [String] Markdown text (with placeholders for protected content)
+      # @return [String] HTML
+      def markdown_to_html(text)
         renderer_options = {
           hard_wrap: false,
           filter_html: false
         }
 
+        # NOTE: fenced_code_blocks is false - we handle code blocks manually
         extensions = {
-          fenced_code_blocks: true,
+          fenced_code_blocks: false,
           autolink: true,
           strikethrough: true,
           tables: true,
@@ -196,7 +241,7 @@ module Botiasloop
 
         renderer = Redcarpet::Render::HTML.new(renderer_options)
         markdown_parser = Redcarpet::Markdown.new(renderer, extensions)
-        html = markdown_parser.render(markdown)
+        html = markdown_parser.render(text)
 
         # Post-process HTML for Telegram compatibility
         process_html_for_telegram(html)
@@ -207,7 +252,7 @@ module Botiasloop
         result = html
 
         # Convert headers to bold
-        result = result.gsub(/<h[1-6][^>]*>(.*?)<\/h[1-6]>/, '<b>\1</b>')
+        result = result.gsub(%r{<h[1-6][^>]*>(.*?)</h[1-6]>}, '<b>\1</b>')
 
         # Convert lists to formatted text
         result = convert_lists(result)
@@ -216,7 +261,7 @@ module Botiasloop
         result = convert_tables(result)
 
         # Convert <br> tags to newlines (Telegram doesn't support <br>)
-        result = result.gsub(/<br\s*\/?>/, "\n")
+        result = result.gsub(%r{<br\s*/?>}, "\n")
 
         # Strip unsupported HTML tags
         strip_unsupported_tags(result)
@@ -225,36 +270,36 @@ module Botiasloop
       # Convert HTML lists to formatted text with bullets/numbers
       def convert_lists(html)
         # Process unordered lists
-        result = html.gsub(/<ul[^>]*>.*?<\/ul>/m) do |ul_block|
-          ul_block.gsub(/<li[^>]*>(.*?)<\/li>/) do |_|
+        result = html.gsub(%r{<ul[^>]*>.*?</ul>}m) do |ul_block|
+          ul_block.gsub(%r{<li[^>]*>(.*?)</li>}) do |_|
             "• #{::Regexp.last_match(1)}<br>"
-          end.gsub(/<\/?ul>/, "")
+          end.gsub(%r{</?ul>}, "")
         end
 
         # Process ordered lists
-        result.gsub(/<ol[^>]*>.*?<\/ol>/m) do |ol_block|
+        result.gsub(%r{<ol[^>]*>.*?</ol>}m) do |ol_block|
           counter = 0
-          ol_block.gsub(/<li[^>]*>(.*?)<\/li>/) do |_|
+          ol_block.gsub(%r{<li[^>]*>(.*?)</li>}) do |_|
             counter += 1
             "#{counter}. #{::Regexp.last_match(1)}<br>"
-          end.gsub(/<\/?ol>/, "")
+          end.gsub(%r{</?ol>}, "")
         end
       end
 
       # Convert HTML tables to properly formatted text wrapped in <pre> tags
       def convert_tables(html)
-        html.gsub(/<table[^>]*>.*?<\/table>/m) do |table_block|
+        html.gsub(%r{<table[^>]*>.*?</table>}m) do |table_block|
           # Extract headers (th elements)
-          headers = table_block.scan(/<th[^>]*>(.*?)<\/th>/).flatten
+          headers = table_block.scan(%r{<th[^>]*>(.*?)</th>}).flatten
 
           # Extract data rows (td elements within tr elements)
           data_rows = []
-          table_block.scan(/<tr[^>]*>(.*?)<\/tr>/m) do |row_match|
+          table_block.scan(%r{<tr[^>]*>(.*?)</tr>}m) do |row_match|
             row_html = row_match[0]
             # Skip rows that only contain th elements (header row)
             next if row_html.include?("<th")
 
-            cells = row_html.scan(/<td[^>]*>(.*?)<\/td>/).flatten
+            cells = row_html.scan(%r{<td[^>]*>(.*?)</td>}).flatten
             data_rows << cells if cells.any?
           end
 
@@ -333,13 +378,21 @@ module Botiasloop
         result = html.dup
 
         # Remove all HTML tags that are not in the allowed list
-        result.gsub!(/<\/?(\w+)[^>]*>/) do |tag|
-          tag_name = tag.gsub(/[<>\/]/, "").split.first
+        result.gsub!(%r{</?(\w+)[^>]*>}) do |tag|
+          tag_name = tag.gsub(%r{[<>/]}, "").split.first
           allowed_tags.include?(tag_name) ? tag : ""
         end
 
         result
       end
+
+      # Escape HTML special characters in text
+      #
+      # @param text [String] Text to escape
+      # @return [String] Escaped text
+      def escape_html(text)
+        text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+      end
     end
 
     # Auto-register Telegram channel when file is loaded

data/lib/botiasloop/channels_manager.rb

@@ -11,9 +11,8 @@ module Botiasloop
   # independent operation and error isolation.
   #
   # @example Basic usage
-  #   config = Botiasloop::Config.load
-  #   manager = Botiasloop::ChannelsManager.new(config)
-  #   manager.start_channels.wait
+  #   manager = Botiasloop::ChannelsManager.new
+  #   manager.start_listening.wait
   #
   class ChannelsManager
     # Time to wait for graceful shutdown before force-killing threads
@@ -22,14 +21,8 @@ module Botiasloop
     # 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)
+    def initialize
       @threads = {}
       @instances = {}
       @mutex = Mutex.new
@@ -46,7 +39,7 @@ module Botiasloop
     #
     # @return [ChannelsManager] self for method chaining
     # @raise [Error] If channels are already running
-    def start_channels
+    def start_listening
       @mutex.synchronize do
         raise Error, "Channels are already running" if @running
 
@@ -61,10 +54,10 @@ module Botiasloop
         next if EXCLUDED_CHANNELS.include?(identifier)
 
         begin
-          instance = channel_class.new(@config)
+          instance = channel_class.new
         rescue Error => e
           if e.message.match?(/Missing required configuration/)
-            @logger.warn "[ChannelsManager] Skipping #{identifier}: #{e.message}"
+            Logger.warn "[ChannelsManager] Skipping #{identifier}: #{e.message}"
             next
           end
           raise
@@ -76,7 +69,7 @@ module Botiasloop
           @instances[identifier] = instance
         end
 
-        @logger.info "[ChannelsManager] Started #{identifier} in thread #{thread.object_id}"
+        Logger.info "[ChannelsManager] Started #{identifier} in thread #{thread.object_id}"
       end
 
       # Monitor threads for crashes
@@ -91,7 +84,7 @@ module Botiasloop
     # to complete. Force-kills threads that don't stop within timeout.
     #
     # @return [void]
-    def stop_all
+    def stop_listening
       @mutex.synchronize do
         return unless @running
 
@@ -99,19 +92,19 @@ module Botiasloop
         @running = false
       end
 
-      @logger.info "[ChannelsManager] Stopping all channels..."
+      Logger.info "[ChannelsManager] Stopping all channels..."
 
       # Stop all channel instances
       @instances.each do |identifier, instance|
-        instance.stop if instance.running?
+        instance.stop_listening if instance.running?
       rescue => e
-        @logger.error "[ChannelsManager] Error stopping #{identifier}: #{e.message}"
+        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"
+          Logger.warn "[ChannelsManager] Force-killing #{identifier} thread"
           thread.kill
         end
       end
@@ -121,7 +114,7 @@ module Botiasloop
         @instances.clear
       end
 
-      @logger.info "[ChannelsManager] All channels stopped"
+      Logger.info "[ChannelsManager] All channels stopped"
     end
 
     # Check if any channels are currently running
@@ -223,10 +216,10 @@ module Botiasloop
         Thread.current.name = "botiasloop-#{identifier}"
 
         begin
-          instance.start
+          instance.start_listening
         rescue => e
-          @logger.error "[ChannelsManager] Channel #{identifier} crashed: #{e.message}"
-          @logger.error "[ChannelsManager] #{e.backtrace&.first(5)&.join("\n")}"
+          Logger.error "[ChannelsManager] Channel #{identifier} crashed: #{e.message}"
+          Logger.error "[ChannelsManager] #{e.backtrace&.first(5)&.join("\n")}"
         end
       end
     end
@@ -248,11 +241,11 @@ module Botiasloop
               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
+              next unless instance&.running?
+
+              Logger.error "[ChannelsManager] Thread for #{identifier} died unexpectedly"
+              @instances.delete(identifier)
+              @threads.delete(identifier)
             end
 
             # Exit monitor if no more threads
@@ -281,8 +274,8 @@ module Botiasloop
     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
+        Logger.info "[ChannelsManager] Received #{signal}, shutting down..."
+        stop_listening
 
         # Call original handler if it exists
         case signal

data/lib/botiasloop/chat.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Botiasloop
+  # Chat model - represents a communication channel between user(s) and agent
+  # A chat belongs to a specific channel (telegram, cli) and external source (chat_id)
+  # Each chat tracks its current conversation (which can be any conversation in the system)
+  class Chat < Sequel::Model(:chats)
+    plugin :validation_helpers
+    plugin :timestamps, update_on_create: true
+
+    many_to_one :current_conversation, class: "Botiasloop::Conversation", key: :current_conversation_id
+
+    # Validations
+    def validate
+      super
+      validates_presence %i[channel external_id]
+      validates_unique %i[channel external_id]
+    end
+
+    # Class method to find or create a chat by channel and external_id
+    #
+    # @param channel [String] Channel type (e.g., "telegram", "cli")
+    # @param external_id [String] External identifier (e.g., chat_id, "cli")
+    # @param user_identifier [String, nil] Optional user identifier (e.g., telegram username)
+    # @return [Chat] Found or created chat
+    def self.find_or_create(channel, external_id, user_identifier: nil)
+      chat = find(channel: channel, external_id: external_id)
+      return chat if chat
+
+      create(
+        channel: channel,
+        external_id: external_id,
+        user_identifier: user_identifier
+      )
+    end
+
+    # Get the current conversation for this chat
+    # Creates a new conversation if none exists or current is archived
+    #
+    # @return [Conversation] Current active conversation
+    def current_conversation
+      conv = super
+
+      if conv.nil? || conv.archived
+        conv = create_new_conversation
+        update(current_conversation_id: conv.id)
+      end
+
+      conv
+    end
+
+    # Switch to a different conversation by label or conversation ID
+    #
+    # @param identifier [String] Conversation label or human-readable ID
+    # @return [Conversation] The switched-to conversation
+    # @raise [Error] If conversation not found
+    def switch_conversation(identifier)
+      identifier = identifier.to_s.strip
+      raise Error, "Usage: /switch <label-or-id>" if identifier.empty?
+
+      # First try to find by label
+      conversation = Conversation.find(label: identifier)
+
+      # If not found by label, treat as ID (case-insensitive)
+      unless conversation
+        normalized_id = HumanId.normalize(identifier)
+        conversation = Conversation.all.find { |c| HumanId.normalize(c.id) == normalized_id }
+      end
+
+      raise Error, "Conversation '#{identifier}' not found" unless conversation
+
+      # Auto-unarchive if switching to archived conversation
+      conversation.update(archived: false) if conversation.archived
+
+      update(current_conversation_id: conversation.id)
+      conversation
+    end
+
+    # Create a new conversation and make it current for this chat
+    #
+    # @return [Conversation] The newly created conversation
+    def create_new_conversation
+      conversation = Conversation.create
+      update(current_conversation_id: conversation.id)
+      conversation
+    end
+
+    # List all non-archived conversations in the system
+    # Sorted by updated_at in descending order (most recently updated first)
+    #
+    # @return [Array<Conversation>] Array of conversations
+    def active_conversations
+      Conversation.where(archived: false).order(Sequel.desc(:updated_at)).all
+    end
+
+    # List all archived conversations in the system
+    #
+    # @return [Array<Conversation>] Array of archived conversations
+    def archived_conversations
+      Conversation.where(archived: true).order(Sequel.desc(:updated_at)).all
+    end
+
+    # Archive the current conversation and create a new one
+    #
+    # @return [Hash] Hash with :archived and :new_conversation keys
+    def archive_current
+      current = current_conversation if current_conversation_id
+
+      raise Error, "No current conversation to archive" unless current
+
+      current.update(archived: true)
+      new_conversation = create_new_conversation
+
+      {
+        archived: current,
+        new_conversation: new_conversation
+      }
+    end
+  end
+end

data/lib/botiasloop/commands/archive.rb

@@ -2,29 +2,39 @@
 
 module Botiasloop
   module Commands
-    # Archive command - archives a conversation by label or UUID, or current conversation if no args
+    # Archive command - archives a conversation by label or ID, or current conversation if no args
     class Archive < Base
       command :archive
-      description "Archive current conversation (no args) or a specific conversation by label/UUID"
+      description "Archive current conversation (no args) or a specific conversation by label/ID"
 
       # 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)
+      # @param args [String, nil] Label or ID 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
+        if identifier.empty?
+          # Archive current conversation and create new one
+          result = context.chat.archive_current
           context.conversation = result[:new_conversation]
           format_archive_current_response(result[:archived], result[:new_conversation])
         else
-          # Archived specific conversation
-          format_archive_response(result[:archived])
+          # Archive specific conversation by label or ID
+          conversation = find_conversation(identifier)
+          raise Botiasloop::Error, "Conversation '#{identifier}' not found" unless conversation
+
+          # Cannot archive current conversation via identifier
+          if conversation.id == context.conversation.id
+            raise Botiasloop::Error,
+              "Cannot archive the current conversation. Use /archive without arguments to archive current and start new."
+          end
+
+          conversation.archive!
+          format_archive_response(conversation)
         end
       rescue Botiasloop::Error => e
         "Error: #{e.message}"
@@ -32,9 +42,22 @@ module Botiasloop
 
       private
 
+      def find_conversation(identifier)
+        # First try to find by label
+        conversation = Conversation.find(label: identifier)
+
+        # If not found by label, treat as ID (case-insensitive)
+        unless conversation
+          normalized_id = HumanId.normalize(identifier)
+          conversation = Conversation.all.find { |c| HumanId.normalize(c.id) == normalized_id }
+        end
+
+        conversation
+      end
+
       def format_archive_response(conversation)
         lines = ["**Conversation archived successfully**"]
-        lines << "- UUID: #{conversation.uuid}"
+        lines << "- ID: #{conversation.uuid}"
 
         lines << if conversation.label?
           "- Label: #{conversation.label}"
@@ -59,7 +82,7 @@ module Botiasloop
         lines = ["**Current conversation archived and new conversation started**"]
         lines << ""
         lines << "Archived:"
-        lines << "- UUID: #{archived.uuid}"
+        lines << "- ID: #{archived.uuid}"
 
         lines << if archived.label?
           "- Label: #{archived.label}"
@@ -79,7 +102,7 @@ module Botiasloop
 
         lines << ""
         lines << "New conversation:"
-        lines << "- UUID: #{new_conversation.uuid}"
+        lines << "- ID: #{new_conversation.uuid}"
         lines << "- Label: (no label)"
 
         lines.join("\n")

data/lib/botiasloop/commands/compact.rb

@@ -14,7 +14,7 @@ module Botiasloop
 
       def execute(context, _args = nil)
         conversation = context.conversation
-        config = context.config
+        config = Config.instance
 
         messages = conversation.history