botiasloop 0.0.1

data/lib/botiasloop/systemd_service.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Botiasloop
+  # Systemd user service management for auto-start on boot
+  #
+  # Manages installation, enablement, and control of botiasloop
+  # as a systemd user service. This allows botiasloop to start
+  # automatically on user login and run in the background.
+  #
+  # @example Install and enable the service
+  #   service = Botiasloop::SystemdService.new(config)
+  #   service.install
+  #   service.enable
+  #   service.start
+  #
+  # @example Check status
+  #   service = Botiasloop::SystemdService.new(config)
+  #   status = service.status
+  #   puts "Running: #{status[:active]}"
+  #
+  class SystemdService
+    attr_reader :config
+
+    # Service name used by systemd
+    SERVICE_NAME = "botiasloop.service"
+
+    # Initialize a new SystemdService instance
+    #
+    # @param config [Config] Configuration instance
+    def initialize(config)
+      @config = config
+    end
+
+    # Check if systemd is available on the system
+    #
+    # @return [Boolean] True if systemctl is available
+    def systemd_available?
+      !`which systemctl 2>/dev/null`.strip.empty?
+    end
+
+    # Check if the service file is installed
+    #
+    # @return [Boolean] True if service file exists
+    def installed?
+      File.exist?(service_file_path)
+    end
+
+    # Check if the service is enabled to start on boot
+    #
+    # @return [Boolean] True if service is enabled
+    def enabled?
+      return false unless systemd_available?
+
+      systemctl_quiet("is-enabled", SERVICE_NAME)
+    end
+
+    # Check if the service is currently active/running
+    #
+    # @return [Boolean] True if service is active
+    def active?
+      return false unless systemd_available?
+
+      systemctl_quiet("is-active", SERVICE_NAME)
+    end
+
+    # Install the service file
+    #
+    # Creates the systemd user directory if needed and writes
+    # the service configuration file.
+    #
+    # @raise [SystemdError] If installation fails
+    # @return [Boolean] True on success
+    def install
+      FileUtils.mkdir_p(systemd_user_dir)
+      File.write(service_file_path, service_template)
+      systemctl("daemon-reload")
+      true
+    rescue => e
+      raise SystemdError, "Failed to install service: #{e.message}"
+    end
+
+    # Uninstall the service
+    #
+    # Stops the service if running, disables it, removes the
+    # service file, and reloads systemd.
+    #
+    # @return [Boolean] True if uninstalled, false if not installed
+    def uninstall
+      return false unless installed?
+
+      stop if active?
+      disable if enabled?
+      FileUtils.rm_f(service_file_path)
+      systemctl("daemon-reload")
+      true
+    end
+
+    # Enable the service to start on boot
+    #
+    # Enables linger to allow user services to start at boot time,
+    # then enables the service. Falls back gracefully if linger fails.
+    #
+    # @raise [SystemdError] If systemd unavailable or service not installed
+    # @return [Boolean] True on success
+    def enable
+      raise SystemdError, "systemd is not available on this system" unless systemd_available?
+      raise SystemdError, "Service is not installed" unless installed?
+
+      enable_linger
+      systemctl("enable", SERVICE_NAME)
+      true
+    end
+
+    # Disable the service from starting on boot
+    #
+    # Disables the service then disables linger if it was enabled.
+    #
+    # @raise [SystemdError] If systemd unavailable
+    # @return [Boolean] True on success
+    def disable
+      raise SystemdError, "systemd is not available on this system" unless systemd_available?
+
+      systemctl("disable", SERVICE_NAME)
+      disable_linger
+      true
+    end
+
+    # Check if linger is enabled for the current user
+    #
+    # Linger allows user services to start at boot time
+    # without requiring a user login session.
+    #
+    # @return [Boolean] True if linger is enabled
+    def linger_enabled?
+      output = `loginctl show-user $USER --property=Linger 2>/dev/null`.strip
+      output == "Linger=yes"
+    end
+
+    # Enable linger for the current user
+    #
+    # Allows user services to start at boot time.
+    # Does nothing if already enabled.
+    #
+    # @return [Boolean] True on success or already enabled, false on failure
+    def enable_linger
+      return true if linger_enabled?
+
+      system("loginctl", "enable-linger", ENV["USER"])
+    end
+
+    # Disable linger for the current user
+    #
+    # Prevents user services from starting at boot time.
+    # Does nothing if already disabled.
+    #
+    # @return [Boolean] True on success or already disabled, false on failure
+    def disable_linger
+      return true unless linger_enabled?
+
+      system("loginctl", "disable-linger", ENV["USER"])
+    end
+
+    # Start the service
+    #
+    # @raise [SystemdError] If systemd unavailable or service not installed
+    # @return [Boolean] True on success
+    def start
+      raise SystemdError, "systemd is not available on this system" unless systemd_available?
+      raise SystemdError, "Service is not installed" unless installed?
+
+      systemctl("start", SERVICE_NAME)
+      true
+    end
+
+    # Stop the service
+    #
+    # @raise [SystemdError] If systemd unavailable
+    # @return [Boolean] True on success
+    def stop
+      raise SystemdError, "systemd is not available on this system" unless systemd_available?
+
+      systemctl("stop", SERVICE_NAME)
+      true
+    end
+
+    # Restart the service
+    #
+    # @raise [SystemdError] If systemd unavailable or service not installed
+    # @return [Boolean] True on success
+    def restart
+      raise SystemdError, "systemd is not available on this system" unless systemd_available?
+      raise SystemdError, "Service is not installed" unless installed?
+
+      systemctl("restart", SERVICE_NAME)
+      true
+    end
+
+    # Get service status information
+    #
+    # @return [Hash] Status with :installed, :enabled, :active, :message keys
+    def status
+      {
+        installed: installed?,
+        enabled: enabled?,
+        active: active?,
+        message: status_message
+      }
+    end
+
+    private
+
+    # Get the systemd user directory path
+    #
+    # @return [String] Path to ~/.config/systemd/user
+    def systemd_user_dir
+      File.join(Dir.home, ".config", "systemd", "user")
+    end
+
+    # Get the full path to the service file
+    #
+    # @return [String] Path to service file
+    def service_file_path
+      File.join(systemd_user_dir, SERVICE_NAME)
+    end
+
+    # Generate the service file content
+    #
+    # @return [String] systemd service unit content
+    def service_template
+      <<~SERVICE
+        [Unit]
+        Description=botiasloop - AI Agent Gateway
+        Documentation=https://github.com/anomalyco/botiasloop
+        After=network.target
+
+        [Service]
+        Type=simple
+        ExecStart=#{executable_path} gateway
+        Restart=on-failure
+        RestartSec=5
+        StandardOutput=journal
+        StandardError=journal
+        Environment="PATH=#{ruby_bin_path}:/usr/local/bin:/usr/bin:/bin"
+
+        [Install]
+        WantedBy=multi-user.target
+      SERVICE
+    end
+
+    # Get the path to the botiasloop executable
+    #
+    # @return [String] Path to botiasloop binary
+    def executable_path
+      Gem.bin_path("botiasloop", "botiasloop")
+    rescue Gem::Exception
+      # Fallback to searching in PATH
+      `which botiasloop 2>/dev/null`.strip
+    end
+
+    # Get the Ruby bin directory for PATH
+    #
+    # @return [String] Path to Ruby bin directory
+    def ruby_bin_path
+      File.dirname(RbConfig.ruby)
+    end
+
+    # Execute a systemctl command
+    #
+    # @param args [Array<String>] Arguments to pass to systemctl
+    # @return [Boolean] True if command succeeded
+    def systemctl(*args)
+      system("systemctl", "--user", *args)
+    end
+
+    # Execute a systemctl command quietly (no output)
+    #
+    # @param args [Array<String>] Arguments to pass to systemctl
+    # @return [Boolean] True if command succeeded
+    def systemctl_quiet(*args)
+      system("systemctl", "--user", *args, out: "/dev/null", err: "/dev/null")
+    end
+
+    # Get a human-readable status message
+    #
+    # @return [String] Status description
+    def status_message
+      if !installed?
+        "Service not installed"
+      elsif active?
+        "Service is running"
+      elsif enabled?
+        "Service enabled but stopped"
+      else
+        "Service installed but disabled"
+      end
+    end
+  end
+end

data/lib/botiasloop/tool.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Botiasloop
+  class Tool < RubyLLM::Tool
+    # Auto-generate tool name from class name in snake_case
+    # Example: WebSearch -> "web_search", MyCustomTool -> "my_custom_tool"
+    def self.tool_name
+      name
+        .split("::")
+        .last
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase
+    end
+
+    # Override RubyLLM's name method to use our tool_name
+    # This ensures the provider receives the correct tool name in schemas
+    def name
+      self.class.tool_name
+    end
+  end
+end

data/lib/botiasloop/tools/registry.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  module Tools
+    class Registry
+      attr_reader :tools
+
+      EMPTY_PARAMETERS_SCHEMA = {
+        "type" => "object",
+        "properties" => {},
+        "required" => [],
+        "additionalProperties" => false,
+        "strict" => true
+      }.freeze
+
+      def initialize
+        @tools = {}
+        @tool_instances = {}
+      end
+
+      # Register a tool class
+      #
+      # @param tool_class [Class] Tool class to register
+      # @param args [Hash] Arguments to pass to tool constructor
+      def register(tool_class, **args)
+        @tools[tool_class.tool_name] = tool_class
+        @tool_instances[tool_class.tool_name] = args
+      end
+
+      # Deregister a tool by name
+      #
+      # @param name [String] Tool name to deregister
+      def deregister(name)
+        @tools.delete(name)
+        @tool_instances.delete(name)
+      end
+
+      # Generate OpenAI-compatible tool schemas
+      # @return [Hash] Hash of tool instances keyed by tool name symbol
+      def schemas
+        @tools.transform_values do |tool_class|
+          args = @tool_instances[tool_class.tool_name]
+          args ? tool_class.new(**args) : tool_class.new
+        end
+      end
+
+      # @return [Array<Class>] Array of registered tool classes
+      def tool_classes
+        @tools.values
+      end
+
+      # Execute a tool by name
+      #
+      # @param name [String] Tool name
+      # @param arguments [Hash] Tool arguments
+      # @return [Hash] Tool result
+      # @raise [Error] If tool not found
+      def execute(name, arguments)
+        tool_class = @tools[name]
+        raise Error, "Unknown tool: #{name}" unless tool_class
+
+        args = @tool_instances[name]
+        tool = args ? tool_class.new(**args) : tool_class.new
+        tool.execute(**arguments.transform_keys(&:to_sym))
+      end
+    end
+  end
+end

data/lib/botiasloop/tools/shell.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../tool"
+
+module Botiasloop
+  module Tools
+    class Shell < Tool
+      description "Execute a shell command and return the output"
+      param :command, type: :string, desc: "The shell command to execute", required: true
+
+      # Execute a shell command
+      #
+      # @param command [String] Shell command to execute
+      # @return [Hash] Result with stdout, stderr, exit_code, and success?
+      def execute(command:)
+        stdout, stderr, status = Open3.capture3(command)
+        Result.new(stdout, stderr, status.exitstatus).to_h
+      end
+
+      # Result wrapper for shell execution
+      class Result
+        attr_reader :stdout, :stderr, :exit_code
+
+        def initialize(stdout, stderr, exit_code)
+          @stdout = stdout
+          @stderr = stderr
+          @exit_code = exit_code
+        end
+
+        def success?
+          @exit_code == 0
+        end
+
+        def to_s
+          "Exit: #{@exit_code}\nStdout:\n#{@stdout}\nStderr:\n#{@stderr}"
+        end
+
+        def to_h
+          {
+            stdout: @stdout,
+            stderr: @stderr,
+            exit_code: @exit_code,
+            success?: success?
+          }
+        end
+      end
+    end
+  end
+end

data/lib/botiasloop/tools/web_search.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require_relative "../tool"
+
+module Botiasloop
+  module Tools
+    class WebSearch < Tool
+      description "Search the web using SearXNG"
+      param :query, type: :string, desc: "The search query", required: true
+
+      # Initialize with SearXNG URL
+      #
+      # @param searxng_url [String] SearXNG instance URL
+      def initialize(searxng_url)
+        @searxng_url = searxng_url
+      end
+
+      # Execute web search
+      #
+      # @param query [String] Search query
+      # @return [Hash] Search results
+      # @raise [Error] On HTTP or connection errors
+      def execute(query:)
+        uri = URI("#{@searxng_url}/search")
+        uri.query = URI.encode_www_form("q" => query, "format" => "json")
+
+        response = Net::HTTP.get_response(uri)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise Error, "Search failed: HTTP #{response.code}"
+        end
+
+        data = JSON.parse(response.body)
+        Result.new(data["results"] || []).to_h
+      rescue Errno::ECONNREFUSED => e
+        raise Error, "Search failed: #{e.message}"
+      rescue JSON::ParserError => e
+        raise Error, "Search failed: Invalid JSON response - #{e.message}"
+      end
+
+      # Result wrapper for search results
+      class Result
+        attr_reader :results
+
+        def initialize(results)
+          @results = results
+        end
+
+        def to_s
+          @results.map do |r|
+            "#{r["title"]}\n#{r["url"]}\n#{r["content"]}"
+          end.join("\n\n")
+        end
+
+        def to_h
+          {results: @results}
+        end
+      end
+    end
+  end
+end

data/lib/botiasloop/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Botiasloop
+  VERSION = "0.0.1"
+end

data/lib/botiasloop.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "botiasloop/version"
+require_relative "botiasloop/config"
+require_relative "botiasloop/database"
+
+require_relative "botiasloop/conversation"
+require_relative "botiasloop/conversation_manager"
+require_relative "botiasloop/tool"
+require_relative "botiasloop/tools/registry"
+require_relative "botiasloop/tools/shell"
+require_relative "botiasloop/tools/web_search"
+require_relative "botiasloop/skills/skill"
+require_relative "botiasloop/skills/loader"
+require_relative "botiasloop/skills/registry"
+require_relative "botiasloop/commands"
+require_relative "botiasloop/loop"
+require_relative "botiasloop/agent"
+require_relative "botiasloop/channels"
+require_relative "botiasloop/channels/base"
+require_relative "botiasloop/channels/cli"
+require_relative "botiasloop/channels/telegram"
+require_relative "botiasloop/channels_manager"
+require_relative "botiasloop/systemd_service"
+
+module Botiasloop
+  class Error < StandardError; end
+
+  # Error raised for systemd service operation failures
+  class SystemdError < Error; end
+
+  # @return [String] Root directory of the gem
+  def self.root
+    File.dirname(__dir__)
+  end
+
+  class MaxIterationsExceeded < Error
+    attr_reader :max_iterations
+
+    def initialize(max_iterations)
+      @max_iterations = max_iterations
+      super("I've reached my thinking limit (#{max_iterations} iterations). Please try a more specific question.")
+    end
+  end
+end