botiasloop 0.0.1

data/lib/botiasloop/conversation_manager.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  # Manages conversation state globally, mapping user IDs to conversation UUIDs
+  # Handles all business logic: switching, finding current, labeling, etc.
+  class ConversationManager
+    # Valid label format: alphanumeric, dashes, and underscores
+    LABEL_REGEX = /\A[a-zA-Z0-9_-]+\z/
+
+    class << self
+      # Get or create the current conversation for a user
+      #
+      # @param user_id [String] User identifier
+      # @return [Conversation] Current conversation for the user
+      def current_for(user_id)
+        user_key = user_id.to_s
+        conversation = Conversation.where(user_id: user_key, is_current: true, archived: false).first
+
+        if conversation
+          Conversation[conversation.id]
+        else
+          create_new(user_key)
+        end
+      end
+
+      # Switch a user to a different conversation by label or UUID
+      # Auto-unarchives archived conversations when switching to them
+      #
+      # @param user_id [String] User identifier
+      # @param identifier [String] Conversation label or UUID to switch to
+      # @return [Conversation] The switched-to conversation
+      # @raise [Error] If conversation with given identifier doesn't exist
+      def switch(user_id, identifier)
+        user_key = user_id.to_s
+        identifier = identifier.to_s.strip
+
+        raise Error, "Usage: /switch <label-or-uuid>" if identifier.empty?
+
+        # First try to find by label (include archived)
+        conversation = Conversation.where(user_id: user_key, label: identifier).first
+
+        # If not found by label, treat as UUID (include archived)
+        conversation ||= Conversation.find(id: identifier, user_id: user_key)
+
+        raise Error, "Conversation '#{identifier}' not found" unless conversation
+
+        # Auto-unarchive if switching to an archived conversation
+        conversation.update(archived: false) if conversation.archived
+
+        # Clear current flag from all user's conversations
+        Conversation.where(user_id: user_key).update(is_current: false)
+
+        # Set new conversation as current
+        conversation.update(is_current: true)
+        Conversation[conversation.id]
+      end
+
+      # Create a new conversation and switch the user to it
+      #
+      # @param user_id [String] User identifier
+      # @return [Conversation] The newly created conversation
+      def create_new(user_id)
+        user_key = user_id.to_s
+
+        # Clear current flag from all user's conversations
+        Conversation.where(user_id: user_key).update(is_current: false)
+
+        # Create new conversation as current
+        conversation = Conversation.create(user_id: user_key, is_current: true)
+        Conversation[conversation.id]
+      end
+
+      # Get the UUID for a user's current conversation
+      #
+      # @param user_id [String] User identifier
+      # @return [String, nil] Current conversation UUID or nil if none exists
+      def current_uuid_for(user_id)
+        conversation = Conversation.where(user_id: user_id.to_s, is_current: true).first
+        conversation&.id
+      end
+
+      # List all conversation mappings (excluding archived by default)
+      #
+      # @param include_archived [Boolean] Whether to include archived conversations
+      # @return [Hash] Hash mapping UUIDs to {user_id, label} hashes
+      def all_mappings(include_archived: false)
+        dataset = include_archived ? Conversation.dataset : Conversation.where(archived: false)
+        dataset.all.map do |conv|
+          [conv.id, {"user_id" => conv.user_id, "label" => conv.label}]
+        end.to_h
+      end
+
+      # Remove a user's current conversation
+      #
+      # @param user_id [String] User identifier
+      def remove(user_id)
+        conversation = Conversation.where(user_id: user_id.to_s, is_current: true).first
+        return unless conversation
+
+        conversation.destroy
+      end
+
+      # Clear all conversations (use with caution)
+      def clear_all
+        Conversation.db[:conversations].delete
+      end
+
+      # Get the label for a conversation
+      #
+      # @param uuid [String] Conversation UUID
+      # @return [String, nil] Label value or nil
+      def label(uuid)
+        conversation = Conversation.find(id: uuid)
+        conversation&.label
+      end
+
+      # Set the label for a conversation
+      #
+      # @param uuid [String] Conversation UUID
+      # @param value [String] Label value
+      # @return [String] The label value
+      # @raise [Error] If label format is invalid or already in use
+      def set_label(uuid, value)
+        conversation = Conversation.find(id: uuid)
+        raise Error, "Conversation not found" unless conversation
+
+        # Validate label format
+        unless value.nil? || value.to_s.empty? || value.to_s.match?(LABEL_REGEX)
+          raise Error, "Invalid label format. Use only letters, numbers, dashes, and underscores."
+        end
+
+        # Check uniqueness per user (excluding current conversation)
+        user_id = conversation.user_id
+        if value && !value.to_s.empty? && label_exists?(user_id, value, exclude_uuid: uuid)
+          raise Error, "Label '#{value}' already in use by another conversation"
+        end
+
+        # Allow empty string to be treated as nil (clearing the label)
+        value = nil if value.to_s.empty?
+
+        Conversation.where(id: uuid).update(label: value)
+        value
+      end
+
+      # Check if a label exists for a user
+      #
+      # @param user_id [String] User identifier
+      # @param label [String] Label to check
+      # @param exclude_uuid [String, nil] UUID to exclude from check
+      # @return [Boolean] True if label exists for user
+      def label_exists?(user_id, label, exclude_uuid: nil)
+        return false unless label
+
+        query = Conversation.where(user_id: user_id.to_s, label: label)
+        query = query.exclude(id: exclude_uuid) if exclude_uuid
+        query.count > 0
+      end
+
+      # List all conversations for a user
+      # Sorted by updated_at in descending order (most recently updated first)
+      #
+      # @param user_id [String] User identifier
+      # @param archived [Boolean, nil] Filter by archived status (nil = all, true = archived only, false = unarchived only)
+      # @return [Array<Hash>] Array of {uuid, label, updated_at} hashes
+      def list_by_user(user_id, archived: false)
+        dataset = Conversation.where(user_id: user_id.to_s)
+        dataset = dataset.where(archived: archived) unless archived.nil?
+        dataset.order(Sequel.desc(:updated_at)).all.map do |conv|
+          {uuid: conv.id, label: conv.label, updated_at: conv.updated_at}
+        end
+      end
+
+      # Find conversation UUID by label for a user
+      #
+      # @param user_id [String] User identifier
+      # @param label [String] Label to search for
+      # @return [String, nil] UUID or nil if not found
+      def find_by_label(user_id, label)
+        conversation = Conversation.where(user_id: user_id.to_s, label: label).first
+        conversation&.id
+      end
+
+      # Archive a conversation by label or UUID, or archive current if no identifier given
+      # When archiving current conversation, automatically creates a new one
+      #
+      # @param user_id [String] User identifier
+      # @param identifier [String, nil] Conversation label or UUID to archive (nil = archive current)
+      # @return [Hash] Hash with :archived and :new_conversation keys
+      # @raise [Error] If conversation not found
+      def archive(user_id, identifier = nil)
+        user_key = user_id.to_s
+        identifier = identifier.to_s.strip
+
+        if identifier.empty?
+          # Archive current conversation
+          conversation = Conversation.where(user_id: user_key, is_current: true).first
+          raise Error, "No current conversation to archive" unless conversation
+
+          # Archive the current conversation
+          conversation.update(archived: true, is_current: false)
+
+          # Create a new conversation (becomes current)
+          new_conversation = create_new(user_key)
+
+          {
+            archived: Conversation[conversation.id],
+            new_conversation: new_conversation
+          }
+        else
+          # Archive by label or UUID
+          conversation = Conversation.where(user_id: user_key, label: identifier).first
+          conversation ||= Conversation.find(id: identifier, user_id: user_key)
+
+          raise Error, "Conversation '#{identifier}' not found" unless conversation
+
+          # Cannot archive current conversation (must use archive without args)
+          raise Error, "Cannot archive the current conversation. Use /archive without arguments to archive current and start new." if conversation.is_current
+
+          conversation.update(archived: true, is_current: false)
+          {archived: Conversation[conversation.id]}
+        end
+      end
+    end
+  end
+end

data/lib/botiasloop/database.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "fileutils"
+
+module Botiasloop
+  # Database connection and schema management for SQLite
+  class Database
+    # Default database path
+    DEFAULT_PATH = File.expand_path("~/.config/botiasloop/db.sqlite")
+
+    class << self
+      # Get or create database connection
+      # Automatically sets up schema on first connection
+      #
+      # @return [Sequel::SQLite::Database]
+      def connect
+        @db ||= begin
+          db = Sequel.sqlite(DEFAULT_PATH)
+          setup_schema!(db)
+          db
+        end
+      end
+
+      # Set up database schema
+      # Creates tables if they don't exist
+      def setup!
+        db = @db || connect
+        setup_schema!(db)
+      end
+
+      # Reset database - delete all data
+      def reset!
+        db = connect
+        db[:messages].delete if db.table_exists?(:messages)
+        db[:conversations].delete if db.table_exists?(:conversations)
+      end
+
+      # Close database connection
+      def disconnect
+        @db&.disconnect
+        @db = nil
+      end
+
+      private
+
+      # Set up database schema on a connection
+      # Creates tables if they don't exist
+      #
+      # @param db [Sequel::SQLite::Database] Database connection
+      def setup_schema!(db)
+        # Ensure directory exists
+        FileUtils.mkdir_p(File.dirname(DEFAULT_PATH))
+
+        # Create conversations table
+        db.create_table?(:conversations) do
+          String :id, primary_key: true
+          String :user_id, null: false
+          String :label
+          TrueClass :is_current, default: false
+          TrueClass :archived, default: false
+          Integer :input_tokens, default: 0
+          Integer :output_tokens, default: 0
+          DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP
+          DateTime :updated_at, default: Sequel::CURRENT_TIMESTAMP
+
+          index [:user_id, :label], unique: true
+          index [:user_id, :archived]
+        end
+
+        # Create messages table
+        db.create_table?(:messages) do
+          primary_key :id
+          String :conversation_id, null: false
+          String :role, null: false
+          String :content, null: false, text: true
+          Integer :input_tokens, default: 0
+          Integer :output_tokens, default: 0
+          DateTime :timestamp, default: Sequel::CURRENT_TIMESTAMP
+          DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP
+
+          foreign_key [:conversation_id], :conversations, on_delete: :cascade
+          index [:conversation_id]
+        end
+      end
+    end
+  end
+end
+
+# Establish database connection when models are loaded
+# This ensures Sequel models have a valid database connection
+Botiasloop::Database.connect

data/lib/botiasloop/loop.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "logger"
+require "json"
+
+module Botiasloop
+  class Loop
+    MAX_TOOL_RETRIES = 3
+
+    # Initialize the ReAct loop
+    #
+    # @param provider [RubyLLM::Provider] Provider instance
+    # @param model [RubyLLM::Model] Model instance
+    # @param registry [Tools::Registry] Tool registry
+    # @param max_iterations [Integer] Maximum ReAct iterations
+    def initialize(provider, model, registry, max_iterations: 20)
+      @provider = provider
+      @model = model
+      @registry = registry
+      @max_iterations = max_iterations
+      @logger = Logger.new($stderr)
+    end
+
+    # Run the ReAct loop
+    #
+    # @param conversation [Conversation] Conversation instance
+    # @param user_input [String] User input
+    # @return [String] Final response
+    # @raise [Error] If max iterations exceeded
+    def run(conversation, user_input)
+      conversation.add("user", user_input)
+      messages = build_messages(conversation)
+
+      # Track accumulated tokens across all iterations
+      total_input_tokens = 0
+      total_output_tokens = 0
+
+      @max_iterations.times do
+        response = iterate(messages)
+
+        # Accumulate tokens from this response
+        total_input_tokens += response.input_tokens || 0
+        total_output_tokens += response.output_tokens || 0
+
+        if response.tool_call?
+          # Add the assistant's message with tool_calls first
+          messages << response
+
+          response.tool_calls.each_value do |tool_call|
+            observation = execute_tool(tool_call)
+            messages << build_tool_result_message(tool_call.id, observation)
+          end
+        else
+          conversation.add("assistant", response.content, input_tokens: total_input_tokens, output_tokens: total_output_tokens)
+          return response.content
+        end
+      end
+
+      raise MaxIterationsExceeded.new(@max_iterations)
+    end
+
+    private
+
+    def build_messages(conversation)
+      system_prompt = [RubyLLM::Message.new(
+        role: :system,
+        content: conversation.system_prompt
+      )]
+
+      system_prompt + conversation.history.map do |msg|
+        role = msg[:role] || msg["role"]
+        content = msg[:content] || msg["content"]
+        RubyLLM::Message.new(
+          role: role.to_sym,
+          content: content
+        )
+      end
+    end
+
+    def iterate(messages)
+      tool_schemas = @registry.schemas
+      @provider.complete(
+        messages,
+        tools: tool_schemas,
+        temperature: nil,
+        model: @model
+      )
+    end
+
+    def build_tool_result_message(tool_call_id, content)
+      RubyLLM::Message.new(
+        role: :tool,
+        content: content,
+        tool_call_id: tool_call_id
+      )
+    end
+
+    def execute_tool(tool_call)
+      @logger.info "[Tool] Executing #{tool_call.name} with arguments: #{tool_call.arguments}"
+      retries = 0
+      begin
+        result = @registry.execute(tool_call.name, tool_call.arguments)
+        build_observation(result)
+      rescue Error => e
+        retries += 1
+        retry if retries < MAX_TOOL_RETRIES
+        "Error: #{e.message}"
+      end
+    end
+
+    def build_observation(result)
+      result.to_s
+    end
+  end
+end

data/lib/botiasloop/skills/loader.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Skills
+    # Discovers and loads skills from gem and user directories
+    class Loader
+      # @return [Array<Skill>] All loaded skills (default + user)
+      def self.load_all_skills
+        load_default_skills + load_user_skills
+      end
+
+      # @return [Array<Skill>] Skills shipped with the gem
+      def self.load_default_skills
+        skills_dir = File.join(Botiasloop.root, "data", "skills")
+        load_from_directory(skills_dir)
+      end
+
+      # @return [Array<Skill>] Skills from user's ~/skills/ directory
+      def self.load_user_skills
+        user_skills_dir = File.expand_path("~/skills")
+        load_from_directory(user_skills_dir)
+      end
+
+      # Load skills from a specific directory
+      # @param dir [String] Directory path containing skill subdirectories
+      # @return [Array<Skill>]
+      def self.load_from_directory(dir)
+        return [] unless File.directory?(dir)
+
+        skills = []
+        Dir.entries(dir).each do |entry|
+          next if entry == "." || entry == ".."
+
+          skill_path = File.join(dir, entry)
+          next unless File.directory?(skill_path)
+
+          skill_md_path = File.join(skill_path, "SKILL.md")
+          next unless File.exist?(skill_md_path)
+
+          begin
+            skills << Skill.new(skill_path)
+          rescue Error => e
+            warn "Failed to load skill from #{skill_path}: #{e.message}"
+          end
+        end
+
+        skills
+      end
+
+      # Find a specific skill by name
+      # @param name [String] Skill name
+      # @return [Skill, nil]
+      def self.find_by_name(name)
+        load_all_skills.find { |skill| skill.name == name }
+      end
+    end
+  end
+end

data/lib/botiasloop/skills/registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "skill"
+require_relative "loader"
+
+module Botiasloop
+  module Skills
+    # Registry for managing available skills
+    class Registry
+      attr_reader :skills
+
+      def initialize
+        @skills = Loader.load_all_skills
+      end
+
+      # Get all skills as formatted table for system prompt
+      # @return [String]
+      def skills_table
+        return "No skills available." if @skills.empty?
+
+        header = "| Skill Name | Description | Path |"
+        separator = "|------------|-------------|------|"
+        rows = @skills.map { |skill| "| #{skill.name} | #{skill.description} | #{skill.path} |" }
+
+        [header, separator, *rows].join("\n")
+      end
+
+      # Find a skill by name
+      # @param name [String]
+      # @return [Skill, nil]
+      def find(name)
+        @skills.find { |skill| skill.name == name }
+      end
+
+      # Get all skill names
+      # @return [Array<String>]
+      def names
+        @skills.map(&:name)
+      end
+    end
+  end
+end

data/lib/botiasloop/skills/skill.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Skills
+    # Represents a skill loaded from a SKILL.md file
+    # Follows the agentskills.io specification
+    class Skill
+      attr_reader :name, :description, :path, :metadata, :license, :compatibility, :skill_md_path, :body
+
+      # @param path [String] Path to skill directory containing SKILL.md
+      def initialize(path)
+        @path = File.expand_path(path)
+        @skill_md_path = File.join(@path, "SKILL.md")
+
+        raise Error, "Skill not found: #{@skill_md_path}" unless File.exist?(@skill_md_path)
+
+        parse_skill_md
+      end
+
+      # @return [String] Full content of SKILL.md
+      def content
+        @content ||= File.read(@skill_md_path)
+      end
+
+      private
+
+      def parse_skill_md
+        file_content = content
+
+        if file_content =~ /^---\s*$
+?(.*?)\n^---\s*$
+?(.*)$/m
+          frontmatter = ::Regexp.last_match(1)
+          @body = ::Regexp.last_match(2).strip
+        else
+          raise Error, "Invalid SKILL.md format (missing frontmatter): #{@skill_md_path}"
+        end
+
+        metadata = parse_frontmatter(frontmatter)
+
+        @name = metadata["name"]
+        @description = metadata["description"]
+        @license = metadata["license"]
+        @compatibility = metadata["compatibility"]
+        @metadata = metadata["metadata"] || {}
+
+        validate!
+      end
+
+      def parse_frontmatter(frontmatter)
+        require "yaml"
+        YAML.safe_load(frontmatter, permitted_classes: [Date, Time])
+      rescue Psych::SyntaxError => e
+        raise Error, "Invalid YAML frontmatter in #{@skill_md_path}: #{e.message}"
+      end
+
+      def validate!
+        raise Error, "Missing 'name' in skill frontmatter: #{@skill_md_path}" if @name.nil? || @name.empty?
+        raise Error, "Missing 'description' in skill frontmatter: #{@skill_md_path}" if @description.nil? || @description.empty?
+
+        validate_name_format!
+      end
+
+      def validate_name_format!
+        # Max 64 characters, lowercase alphanumeric and hyphens only
+        # Must not start or end with hyphen, no consecutive hyphens
+        unless @name =~ /\A[a-z0-9]+(-[a-z0-9]+)*\z/ && @name.length <= 64
+          raise Error, "Invalid skill name '#{@name}' in #{@skill_md_path}. " \
+            "Must be 1-64 chars, lowercase alphanumeric and hyphens only, " \
+            "no leading/trailing/consecutive hyphens."
+        end
+      end
+    end
+  end
+end