botiasloop 0.0.1 → 0.0.7

data/lib/botiasloop/agent.rb

@@ -1,16 +1,28 @@
 # frozen_string_literal: true
 
 require "ruby_llm"
-require "logger"
 
 module Botiasloop
   class Agent
+    @instance = nil
+
+    class << self
+      # @return [Agent] Singleton instance of the agent
+      def instance
+        @instance ||= new
+      end
+
+      # @return [Agent] Singleton instance of the agent (alias for instance)
+      def chat(message, conversation: nil, verbose_callback: nil)
+        instance.chat(message, conversation: conversation, verbose_callback: verbose_callback)
+      end
+
+      # Set the instance directly (primarily for testing)
+      # @param agent [Agent, nil] Agent instance or nil to reset
+      attr_writer :instance
+    end
     # Initialize the agent
-    #
-    # @param config [Config, nil] Configuration instance (loads default if nil)
-    def initialize(config = nil)
-      @config = config || Config.new
-      @logger = Logger.new($stderr)
+    def initialize
       setup_ruby_llm
     end
 
@@ -18,15 +30,16 @@ module Botiasloop
     #
     # @param message [String] User message
     # @param conversation [Conversation, nil] Existing conversation
+    # @param verbose_callback [Proc, nil] Callback for verbose messages
     # @return [String] Assistant response
-    def chat(message, conversation: nil)
+    def chat(message, conversation: nil, verbose_callback: nil)
       conversation ||= Conversation.new
 
       registry = create_registry
       provider, model = create_provider_and_model
-      loop = Loop.new(provider, model, registry, max_iterations: @config.max_iterations)
+      loop = Loop.new(provider, model, registry, max_iterations: Config.instance.max_iterations)
 
-      loop.run(conversation, message)
+      loop.run(conversation, message, verbose_callback)
     rescue MaxIterationsExceeded => e
       e.message
     end
@@ -34,7 +47,7 @@ module Botiasloop
     private
 
     def setup_ruby_llm
-      provider_name, provider_config = @config.active_provider
+      provider_name, provider_config = Config.instance.active_provider
 
       RubyLLM.configure do |config|
         configure_provider(config, provider_name, provider_config)
@@ -85,7 +98,7 @@ module Botiasloop
     end
 
     def create_provider_and_model
-      _provider_name, provider_config = @config.active_provider
+      _provider_name, provider_config = Config.instance.active_provider
       model_id = provider_config["model"]
       model = RubyLLM::Models.find(model_id)
       provider_class = RubyLLM::Provider.for(model_id)
@@ -106,7 +119,7 @@ module Botiasloop
     end
 
     def web_search_url
-      @config.tools["web_search"]["searxng_url"]
+      Config.instance.tools["web_search"]["searxng_url"]
     end
   end
 end

data/lib/botiasloop/auto_label.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "logger"
+
+module Botiasloop
+  # Service class for automatically generating conversation labels
+  # Triggered after 3rd user message if no label is set
+  class AutoLabel
+    MIN_MESSAGES_FOR_AUTO_LABEL = 6 # 3 user + 3 assistant messages
+
+    # Generate a label for the conversation if conditions are met
+    #
+    # @param conversation [Conversation] The conversation to label
+    # @return [String, nil] The generated label or nil if not applicable
+    def self.generate(conversation)
+      return nil unless should_generate?(conversation)
+
+      label = new.generate_label(conversation)
+
+      Logger.info "[AutoLabel] Generated label '#{label}' for conversation #{conversation.uuid}" if label
+
+      label
+    end
+
+    # Check if auto-labelling should run
+    #
+    # @param conversation [Conversation] The conversation to check
+    # @return [Boolean] True if conditions are met
+    def self.should_generate?(conversation)
+      return false unless Config.instance.features&.dig("auto_labelling", "enabled") != false
+      return false if conversation.label?
+      return false if conversation.message_count < MIN_MESSAGES_FOR_AUTO_LABEL
+
+      true
+    end
+
+    def initialize
+      @config = Config.instance
+    end
+
+    # Generate a label based on conversation content
+    #
+    # @param conversation [Conversation] The conversation to label
+    # @return [String, nil] The generated and formatted label
+    def generate_label(conversation)
+      messages = conversation.history
+      raw_label = generate_label_text(messages)
+      return nil unless raw_label
+
+      formatted_label = format_label(raw_label)
+      return nil unless valid_label?(formatted_label)
+
+      formatted_label
+    end
+
+    private
+
+    def generate_label_text(messages)
+      chat = create_chat
+
+      conversation_text = messages.first(MIN_MESSAGES_FOR_AUTO_LABEL).map do |msg|
+        "#{msg[:role]}: #{msg[:content]}"
+      end.join("\n\n")
+
+      prompt = <<~PROMPT
+        Based on the following conversation, generate a short label (1-2 words) that describes the topic.
+        Use lowercase letters only. If two words, separate them with a dash (-).
+        Examples: "coding-help", "travel-planning", "recipe-ideas", "debugging"
+
+        Conversation:
+        #{conversation_text}
+
+        Label (respond with just the label, nothing else):
+      PROMPT
+
+      chat.add_message(role: :user, content: prompt)
+      response = chat.complete
+
+      response.content&.strip
+    rescue
+      nil
+    end
+
+    def create_chat
+      label_config = @config.features["auto_labelling"] || {}
+
+      if label_config["model"]
+        RubyLLM.chat(model: label_config["model"])
+      else
+        default_model = @config.providers["openrouter"]["model"]
+        RubyLLM.chat(model: default_model)
+      end
+    end
+
+    def format_label(raw_label)
+      # Remove non-alphanumeric characters except dashes, underscores, and spaces
+      cleaned = raw_label.gsub(/[^a-zA-Z0-9\s\-_]/, "")
+
+      # Split into words (by whitespace only, preserve underscores in words)
+      words = cleaned.split(/\s+/).reject(&:empty?)
+
+      # Take max 2 words
+      words = words.first(2)
+
+      # Join with dash, lowercase
+      words.join("-").downcase
+    end
+
+    def valid_label?(label)
+      return false if label.nil? || label.empty?
+      return false unless label.match?(Conversation::LABEL_REGEX)
+
+      true
+    end
+  end
+end

data/lib/botiasloop/channels/base.rb

@@ -2,7 +2,6 @@
 
 require "json"
 require "fileutils"
-require "logger"
 
 module Botiasloop
   module Channels
@@ -14,9 +13,7 @@ module Botiasloop
         # @param name [Symbol] Channel identifier (e.g., :telegram)
         # @return [Symbol] The channel identifier
         def channel_name(name = nil)
-          if name
-            @channel_identifier = name
-          end
+          @channel_identifier = name if name
           @channel_identifier
         end
 
@@ -39,12 +36,8 @@ module Botiasloop
 
       # Initialize the channel
       #
-      # @param config [Config] Configuration instance
       # @raise [Error] If required configuration is missing
-      def initialize(config)
-        @config = config
-        @logger = Logger.new($stderr)
-
+      def initialize
         validate_required_config!
       end
 
@@ -53,19 +46,27 @@ module Botiasloop
       #
       # @return [Hash] Channel configuration hash
       def channel_config
-        @config.channels[self.class.channel_identifier.to_s] || {}
+        Config.instance.channels[self.class.channel_identifier.to_s] || {}
+      end
+
+      # Get the channel type string (e.g., "telegram", "cli")
+      # Override in subclasses if needed
+      #
+      # @return [String] Channel type string
+      def channel_type
+        self.class.channel_identifier.to_s
       end
 
       # Start the channel and begin listening for messages
       # @raise [NotImplementedError] Subclass must implement
-      def start
-        raise NotImplementedError, "Subclass must implement #start"
+      def start_listening
+        raise NotImplementedError, "Subclass must implement #start_listening"
       end
 
       # Stop the channel and cleanup
       # @raise [NotImplementedError] Subclass must implement
-      def stop
-        raise NotImplementedError, "Subclass must implement #stop"
+      def stop_listening
+        raise NotImplementedError, "Subclass must implement #stop_listening"
       end
 
       # Check if the channel is currently running
@@ -80,7 +81,7 @@ module Botiasloop
       # @param source_id [String] Unique identifier for the message source (e.g., chat_id, user_id)
       # @param raw_message [Object] Raw message object (varies by channel)
       # @param metadata [Hash] Additional metadata about the message
-      def process_message(source_id, raw_message, metadata = {})
+      def process_message(source_id, raw_message, _metadata = {})
         # Hook: Extract content from raw message
         content = extract_content(raw_message)
         return if content.nil? || content.to_s.empty?
@@ -98,22 +99,25 @@ module Botiasloop
         before_process(source_id, user_id, content, raw_message)
 
         # Core processing logic
-        conversation = conversation_for(source_id)
+        chat = chat_for(source_id, user_identifier: user_id)
+        conversation = chat.current_conversation
 
         response = if Commands.command?(content)
           context = Commands::Context.new(
             conversation: conversation,
-            config: @config,
+            chat: chat,
             channel: self,
             user_id: source_id
           )
           Commands.execute(content, context)
         else
-          agent = Agent.new(@config)
-          agent.chat(content, conversation: conversation)
+          verbose_callback = proc do |verbose_message|
+            send_message(source_id, verbose_message)
+          end
+          Agent.chat(content, conversation: conversation, verbose_callback: verbose_callback)
         end
 
-        send_response(source_id, response)
+        send_message(source_id, response)
 
         # Hook: Post-processing
         after_process(source_id, user_id, response, raw_message)
@@ -136,7 +140,7 @@ module Botiasloop
       # @param source_id [String] Source identifier
       # @param raw_message [Object] Raw message object
       # @return [String] User ID for authorization
-      def extract_user_id(source_id, raw_message)
+      def extract_user_id(source_id, _raw_message)
         source_id
       end
 
@@ -168,8 +172,8 @@ module Botiasloop
       # @param source_id [String] Source identifier
       # @param user_id [String] User ID that was denied
       # @param raw_message [Object] Raw message object
-      def handle_unauthorized(source_id, user_id, raw_message)
-        @logger.warn "[#{self.class.channel_identifier}] Unauthorized access from #{user_id} (source: #{source_id})"
+      def handle_unauthorized(source_id, user_id, _raw_message)
+        Logger.warn "[#{self.class.channel_identifier}] Unauthorized access from #{user_id} (source: #{source_id})"
       end
 
       # Handle errors during message processing
@@ -179,8 +183,8 @@ module Botiasloop
       # @param user_id [String] User ID
       # @param error [Exception] The error that occurred
       # @param raw_message [Object] Raw message object
-      def handle_error(source_id, user_id, error, raw_message)
-        @logger.error "[#{self.class.channel_identifier}] Error processing message: #{error.message}"
+      def handle_error(_source_id, _user_id, error, _raw_message)
+        Logger.error "[#{self.class.channel_identifier}] Error processing message: #{error.message}"
         raise error
       end
 
@@ -188,43 +192,43 @@ module Botiasloop
       #
       # @param source_id [String] Source identifier to check
       # @return [Boolean] False by default (secure default)
-      def authorized?(source_id)
+      def authorized?(_source_id)
         false
       end
 
-      # Get or create a conversation for a source
-      # Uses the global ConversationManager for state management.
+      # Get or create a chat for a source
       #
       # @param source_id [String] Source identifier
-      # @return [Conversation] Conversation instance
-      def conversation_for(source_id)
-        ConversationManager.current_for(source_id)
+      # @param user_identifier [String, nil] Optional user identifier (e.g., username)
+      # @return [Chat] Chat instance
+      def chat_for(source_id, user_identifier: nil)
+        Chat.find_or_create(channel_type, source_id, user_identifier: user_identifier)
       end
 
-      # Format a response for this channel
+      # Format a message for this channel
       #
-      # @param content [String] Raw response content
-      # @return [String] Formatted response
-      def format_response(content)
+      # @param content [String] Raw message content
+      # @return [String] Formatted message
+      def format_message(content)
         content
       end
 
-      # Send a response to a source
+      # Send a message to a source
       #
       # @param source_id [String] Source identifier
-      # @param response [String] Response content
-      def send_response(source_id, response)
-        formatted = format_response(response)
-        deliver_response(source_id, formatted)
+      # @param message [String] Message content
+      def send_message(source_id, message)
+        formatted = format_message(message)
+        deliver_message(source_id, formatted)
       end
 
-      # Deliver a formatted response to a source
+      # Deliver a formatted message to a source
       #
       # @param source_id [String] Source identifier
-      # @param formatted_content [String] Formatted response content
+      # @param formatted_content [String] Formatted message content
       # @raise [NotImplementedError] Subclass must implement
-      def deliver_response(source_id, formatted_content)
-        raise NotImplementedError, "Subclass must implement #deliver_response"
+      def deliver_message(source_id, formatted_content)
+        raise NotImplementedError, "Subclass must implement #deliver_message"
       end
 
       private

data/lib/botiasloop/channels/cli.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "logger"
-
 module Botiasloop
   module Channels
     class CLI < Base
@@ -11,17 +9,15 @@ module Botiasloop
       SOURCE_ID = "cli"
 
       # Initialize CLI channel
-      #
-      # @param config [Config] Configuration instance
-      def initialize(config)
+      def initialize
         super
         @running = false
       end
 
       # Start the CLI interactive mode
-      def start
+      def start_listening
         @running = true
-        @logger.info "[CLI] Starting interactive mode..."
+        Logger.info "[CLI] Starting interactive mode..."
 
         puts "botiasloop v#{VERSION} - Interactive Mode"
         puts "Type 'exit', 'quit', or '\\q' to exit"
@@ -37,17 +33,17 @@ module Botiasloop
         end
 
         @running = false
-        @logger.info "[CLI] Interactive mode ended"
+        Logger.info "[CLI] Interactive mode ended"
       rescue Interrupt
         @running = false
         puts "\nGoodbye!"
-        @logger.info "[CLI] Interrupted by user"
+        Logger.info "[CLI] Interrupted by user"
       end
 
       # Stop the CLI channel
-      def stop
+      def stop_listening
         @running = false
-        @logger.info "[CLI] Stopping..."
+        Logger.info "[CLI] Stopping..."
       end
 
       # Check if CLI channel is running
@@ -70,7 +66,7 @@ module Botiasloop
       #
       # @param source_id [String] Source identifier to check
       # @return [Boolean] Always true for CLI
-      def authorized?(source_id)
+      def authorized?(_source_id)
         true
       end
 
@@ -80,16 +76,16 @@ module Botiasloop
       # @param user_id [String] User ID
       # @param error [Exception] The error that occurred
       # @param raw_message [Object] Raw message object
-      def handle_error(source_id, user_id, error, raw_message)
-        @logger.error "[CLI] Error processing message: #{error.message}"
-        send_response(source_id, "Error: #{error.message}")
+      def handle_error(source_id, _user_id, error, _raw_message)
+        Logger.error "[CLI] Error processing message: #{error.message}"
+        send_message(source_id, "Error: #{error.message}")
       end
 
-      # Deliver a formatted response to the CLI
+      # Deliver a formatted message to the CLI
       #
       # @param source_id [String] Source identifier
-      # @param formatted_content [String] Formatted response content
-      def deliver_response(source_id, formatted_content)
+      # @param formatted_content [String] Formatted message content
+      def deliver_message(_source_id, formatted_content)
         puts "Agent: #{formatted_content}"
         puts
       end