botiasloop 0.0.1

data/lib/botiasloop/commands/help.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Help command - displays available slash commands
+    class Help < Base
+      command :help
+      description "Show available commands"
+
+      # Execute the help command
+      #
+      # @param context [Context] Execution context
+      # @param _args [String, nil] Unused arguments
+      # @return [String] Formatted list of commands
+      def execute(context, _args = nil)
+        commands = Botiasloop::Commands.registry.all
+
+        lines = ["**Available commands**"]
+
+        commands.each do |cmd_class|
+          name = cmd_class.command_name
+          desc = cmd_class.description || "No description"
+          lines << "/#{name} - #{desc}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/label.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Label command - manages conversation labels
+    class Label < Base
+      command :label
+      description "Set or show conversation label"
+
+      # Execute the label command
+      #
+      # @param context [Context] Execution context
+      # @param args [String, nil] Label value or nil to show current
+      # @return [String] Command response
+      def execute(context, args = nil)
+        conversation = context.conversation
+        user_id = context.user_id
+
+        if args.nil? || args.strip.empty?
+          # Show current label
+          return show_label(conversation)
+        end
+
+        # Set label
+        label_value = args.strip
+        set_label(conversation, user_id, label_value)
+      end
+
+      private
+
+      def show_label(conversation)
+        if conversation.label?
+          "Current label: #{conversation.label}"
+        else
+          "No label set. Use /label <name> to set one."
+        end
+      end
+
+      def set_label(conversation, user_id, label_value)
+        # Validate label format
+        unless label_value.match?(/\A[a-zA-Z0-9_-]+\z/)
+          return "Invalid label format. Use only letters, numbers, dashes, and underscores."
+        end
+
+        # Check uniqueness per user
+        if label_in_use?(user_id, label_value, conversation.uuid)
+          return "Label '#{label_value}' already in use by another conversation."
+        end
+
+        conversation.update(label: label_value)
+        "Label set to: #{label_value}"
+      rescue Botiasloop::Error => e
+        "Error setting label: #{e.message}"
+      end
+
+      def label_in_use?(user_id, label, current_uuid)
+        return false if user_id.nil?
+
+        existing_uuid = ConversationManager.find_by_label(user_id, label)
+        existing_uuid && existing_uuid != current_uuid
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/new.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Botiasloop
+  module Commands
+    # New command - creates a new conversation
+    class New < Base
+      command :new
+      description "Start a new conversation"
+
+      def execute(context, _args = nil)
+        new_conversation = ConversationManager.create_new(context.user_id)
+        context.conversation = new_conversation
+
+        "**New conversation started (UUID: #{new_conversation.uuid}).**\n" \
+        "Use `/switch #{new_conversation.uuid}` to return later."
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/registry.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Registry for slash commands
+    # Manages command registration, lookup, and execution
+    class Registry
+      # Regex pattern to match slash commands at the start of a message
+      # Captures command name and optional arguments
+      COMMAND_PATTERN = /^\/([a-zA-Z0-9_]+)(?:\s+(.+))?$/
+
+      def initialize
+        @commands = {}
+      end
+
+      # Register a command class
+      #
+      # @param command_class [Class] Command class inheriting from Base
+      # @raise [Error] If command class doesn't have a command_name
+      def register(command_class)
+        name = command_class.command_name
+        raise Error, "Command class must define command name" unless name
+
+        @commands[name] = command_class
+      end
+
+      # Get a command class by name
+      #
+      # @param name [Symbol] Command name
+      # @return [Class, nil] Command class or nil if not found
+      def [](name)
+        @commands[name]
+      end
+
+      # Get all registered command classes
+      #
+      # @return [Array<Class>] Array of command classes sorted by name
+      def all
+        @commands.values.sort_by(&:command_name)
+      end
+
+      # Get all registered command names
+      #
+      # @return [Array<Symbol>] Array of command names sorted
+      def names
+        @commands.keys.sort
+      end
+
+      # Clear all registered commands
+      # Useful for testing to prevent state leakage
+      def clear
+        @commands.clear
+      end
+
+      # Check if a message is a valid command
+      # Must start with / and be a registered command
+      #
+      # @param message [String] Message text to check
+      # @return [Boolean] True if message is a registered command
+      def command?(message)
+        return false unless message.is_a?(String)
+
+        match = message.match(COMMAND_PATTERN)
+        return false unless match
+
+        name = match[1]&.to_sym
+        @commands.key?(name)
+      end
+
+      # Execute a command from a message
+      #
+      # @param message [String] Full command message (e.g., "/help" or "/switch label")
+      # @param context [Context] Execution context
+      # @return [String] Command response or error message
+      def execute(message, context)
+        match = message.match(COMMAND_PATTERN)
+        return unknown_command_response(message) unless match
+
+        name = match[1]&.to_sym
+        args = match[2]
+
+        command_class = @commands[name]
+        return unknown_command_response(message) unless command_class
+
+        command = command_class.new
+        command.execute(context, args)
+      end
+
+      private
+
+      def unknown_command_response(message)
+        name = message.match(COMMAND_PATTERN)&.[](1) || "unknown"
+        "Unknown command: /#{name}. Type /help for available commands."
+      end
+    end
+
+    # Singleton registry instance
+    #
+    # @return [Registry] The global command registry
+    def self.registry
+      @registry ||= Registry.new
+    end
+
+    # Check if a message is a command
+    #
+    # @param message [String] Message to check
+    # @return [Boolean] True if message is a registered command
+    def self.command?(message)
+      registry.command?(message)
+    end
+
+    # Execute a command from a message
+    #
+    # @param message [String] Full command message
+    # @param context [Context] Execution context
+    # @return [String] Command response or error message
+    def self.execute(message, context)
+      registry.execute(message, context)
+    end
+  end
+end

data/lib/botiasloop/commands/reset.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Reset command - clears conversation history
+    class Reset < Base
+      command :reset
+      description "Clear conversation history"
+
+      def execute(context, _args = nil)
+        conversation = context.conversation
+        conversation.reset!
+
+        "Conversation #{conversation.uuid} history and tokens cleared."
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/status.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Status command - shows current conversation status
+    class Status < Base
+      command :status
+      description "Show current conversation status"
+
+      def execute(context, _args = nil)
+        conversation = context.conversation
+        config = context.config
+
+        lines = ["**Conversation Status**"]
+        lines << "UUID: #{conversation.uuid}"
+        lines << "Label: #{format_label(conversation)}"
+        lines << "Model: #{config.providers["openrouter"]["model"]}"
+        lines << "Max iterations: #{config.max_iterations}"
+        lines << "Messages: #{conversation.history.length}"
+        lines << "Tokens: #{conversation.total_tokens} (#{conversation.input_tokens || 0} in / #{conversation.output_tokens || 0} out)"
+
+        lines.join("\n")
+      end
+
+      private
+
+      def format_label(conversation)
+        conversation.label? ? conversation.label : "(none - use /label <name> to set)"
+      end
+    end
+  end
+end

data/lib/botiasloop/commands/switch.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # Switch command - switches to a different conversation by label or UUID
+    class Switch < Base
+      command :switch
+      description "Switch to a different conversation by label or UUID"
+
+      # Execute the switch command
+      #
+      # @param context [Context] Execution context
+      # @param args [String, nil] Label or UUID to switch to
+      # @return [String] Command response with conversation preview
+      def execute(context, args = nil)
+        identifier = args.to_s.strip
+
+        if identifier.empty?
+          return "Usage: /switch <label-or-uuid>"
+        end
+
+        new_conversation = ConversationManager.switch(context.user_id, identifier)
+        context.conversation = new_conversation
+
+        format_switch_response(new_conversation)
+      rescue Botiasloop::Error => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      def format_switch_response(conversation)
+        lines = ["**Conversation switched**"]
+        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_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/system_prompt.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Commands
+    # System prompt command - displays the current system prompt
+    class SystemPrompt < Base
+      command :systemprompt
+      description "Display the system prompt"
+
+      # Execute the systemprompt command
+      #
+      # @param context [Context] Execution context
+      # @param _args [String, nil] Unused - command takes no arguments
+      # @return [String] The system prompt
+      def execute(context, _args = nil)
+        context.conversation.system_prompt
+      end
+    end
+  end
+end

data/lib/botiasloop/commands.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "commands/context"
+require_relative "commands/base"
+require_relative "commands/registry"
+require_relative "commands/help"
+require_relative "commands/status"
+require_relative "commands/reset"
+require_relative "commands/new"
+require_relative "commands/compact"
+require_relative "commands/label"
+require_relative "commands/conversations"
+require_relative "commands/switch"
+require_relative "commands/archive"
+require_relative "commands/system_prompt"
+
+module Botiasloop
+  # Slash commands module
+  # Provides a registry-based command system for bot control
+  module Commands
+  end
+end

data/lib/botiasloop/config.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "anyway_config"
+
+Anyway::Settings.default_config_path = ->(_) { File.expand_path("~/.config/botiasloop/config.yml") }
+
+module Botiasloop
+  class Config < Anyway::Config
+    attr_config \
+      max_iterations: 20,
+      tools: {
+        web_search: {}
+      },
+      providers: {
+        openrouter: {
+          model: "moonshotai/kimi-k2.5"
+        }
+      },
+      channels: {
+        telegram: {
+          allowed_users: []
+        }
+      },
+      commands: {
+        summarize: {}
+      }
+
+    # Validation
+    required :providers
+
+    # Returns the first configured provider name and its config
+    # @return [Array<String, Hash>] provider name and config
+    def active_provider
+      providers.each do |name, config|
+        return [name.to_s, config] if provider_configured?(name, config)
+      end
+      ["openrouter", providers["openrouter"]]
+    end
+
+    private
+
+    def provider_configured?(name, config)
+      # Local providers need api_base
+      return true if %w[ollama gpustack].include?(name.to_s) && config["api_base"]
+
+      # Cloud providers need api_key
+      return true if config["api_key"]
+
+      # VertexAI needs project_id
+      return true if name.to_s == "vertexai" && config["project_id"]
+
+      # Azure needs api_base (and either api_key or ai_auth_token)
+      return true if name.to_s == "azure" && config["api_base"]
+
+      false
+    end
+  end
+end

data/lib/botiasloop/conversation.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Botiasloop
+  # Conversation model - represents a chat conversation with messages
+  # Direct Sequel model with all database and business logic combined
+  class Conversation < Sequel::Model(:conversations)
+    # Message model nested within Conversation namespace
+    class Message < Sequel::Model(:messages)
+      plugin :validation_helpers
+      plugin :timestamps, update_on_create: true
+
+      many_to_one :conversation, class: "Botiasloop::Conversation", key: :conversation_id
+
+      # Validations
+      def validate
+        super
+        validates_presence [:conversation_id, :role, :content]
+      end
+
+      # Convert message to hash for API compatibility
+      # @return [Hash] Message as hash with symbol keys
+      def to_hash
+        {
+          role: role,
+          content: content,
+          input_tokens: input_tokens || 0,
+          output_tokens: output_tokens || 0,
+          timestamp: timestamp.iso8601
+        }
+      end
+    end
+
+    one_to_many :messages, class: "Botiasloop::Conversation::Message", key: :conversation_id
+
+    # Set up validations and hooks
+    plugin :validation_helpers
+    plugin :timestamps, update_on_create: true
+
+    # Allow setting primary key (id) for UUID
+    unrestrict_primary_key
+
+    # Auto-generate UUID before creation if not provided
+    def before_create
+      self.id ||= SecureRandom.uuid
+      super
+    end
+
+    # Validations
+    def validate
+      super
+      validates_presence [:user_id]
+
+      if label && !label.to_s.empty?
+        validates_format ConversationManager::LABEL_REGEX, :label, message: "Invalid label format. Use only letters, numbers, dashes, and underscores."
+        validates_unique [:user_id, :label], message: "Label '#{label}' already in use by another conversation"
+      end
+    end
+
+    # Check if this conversation has a label
+    #
+    # @return [Boolean] True if label is set
+    def label?
+      !label.nil? && !label.to_s.empty?
+    end
+
+    # Get the timestamp of the last activity in the conversation
+    #
+    # @return [String, nil] ISO8601 timestamp of last message, or nil if no messages
+    def last_activity
+      return nil if messages.empty?
+
+      messages_dataset.order(:timestamp).last.timestamp.utc.iso8601
+    end
+
+    # Get the number of messages in the conversation
+    #
+    # @return [Integer] Message count
+    def message_count
+      messages.count
+    end
+
+    # Get total tokens (input + output) for the conversation
+    #
+    # @return [Integer] Total token count
+    def total_tokens
+      (input_tokens || 0) + (output_tokens || 0)
+    end
+
+    # Add a message to the conversation
+    #
+    # @param role [String] Role of the message sender (user, assistant, system)
+    # @param content [String] Message content
+    # @param input_tokens [Integer] Input tokens for this message (prompt tokens sent to LLM)
+    # @param output_tokens [Integer] Output tokens for this message (completion tokens from LLM)
+    def add(role, content, input_tokens: 0, output_tokens: 0)
+      Message.create(
+        conversation_id: id,
+        role: role,
+        content: content,
+        input_tokens: input_tokens || 0,
+        output_tokens: output_tokens || 0,
+        timestamp: Time.now.utc
+      )
+
+      # Update conversation token totals
+      update_token_totals(input_tokens, output_tokens)
+    end
+
+    # Update conversation-level token totals
+    #
+    # @param input_tokens [Integer] Input tokens to add
+    # @param output_tokens [Integer] Output tokens to add
+    def update_token_totals(input_tokens, output_tokens)
+      self.input_tokens = (self.input_tokens || 0) + (input_tokens || 0)
+      self.output_tokens = (self.output_tokens || 0) + (output_tokens || 0)
+      save if modified?
+    end
+
+    # Get conversation history as array of message hashes
+    #
+    # @return [Array<Hash>] Array of message hashes with role, content, timestamp
+    def history
+      messages_dataset.order(:timestamp).map(&:to_hash)
+    end
+
+    # @return [String] UUID of the conversation
+    def uuid
+      # Return existing id or generate a new one for unsaved records
+      self.id ||= SecureRandom.uuid
+    end
+
+    # Reset conversation - clear all messages and reset token counts
+    def reset!
+      messages_dataset.delete
+      self.input_tokens = 0
+      self.output_tokens = 0
+      save
+    end
+
+    # Compact conversation by replacing old messages with a summary
+    #
+    # @param summary [String] Summary of older messages
+    # @param recent_messages [Array<Hash>] Recent messages to keep
+    def compact!(summary, recent_messages)
+      reset!
+      add("system", summary)
+      recent_messages.each do |msg|
+        add(msg[:role], msg[:content])
+      end
+    end
+
+    # Generate the system prompt for this conversation
+    # Includes current date/time and environment info
+    #
+    # @return [String] System prompt
+    def system_prompt
+      skills_registry = Skills::Registry.new
+
+      prompt = <<~PROMPT
+        You are Botias, an autonomous AI agent.
+
+        Environment:
+        - OS: #{RUBY_PLATFORM}
+        - Shell: #{ENV.fetch("SHELL", "unknown")}
+        - Working Directory: #{Dir.pwd}
+        - Date: #{Time.now.strftime("%Y-%m-%d")}
+        - Time: #{Time.now.strftime("%H:%M:%S %Z")}
+
+        You operate in a ReAct loop: Reason about the task, Act using tools, Observe results.
+      PROMPT
+
+      if skills_registry.skills.any?
+        prompt += <<~SKILLS
+
+          Available Skills:
+          #{skills_registry.skills_table}
+
+          To use a skill, read its SKILL.md file at the provided path using the shell tool (e.g., `cat ~/skills/skill-name/SKILL.md`).
+          Skills follow progressive disclosure: only metadata is shown above. Full instructions are loaded on demand.
+        SKILLS
+      end
+
+      prompt
+    end
+  end
+end