ruboty-ai_agent 0.2.0 → 0.4.0

data/lib/ruboty/ai_agent/tool_definitions/bot_help.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module ToolDefinitions
+      # Tool for retrieving Ruboty help information
+      class BotHelp < Base
+        self.tool_name = 'bot_help'
+        self.tool_title = 'Show help information about this bot (you)'
+
+        self.tool_description = <<~TEXT
+          Get help information about available patterns of this bot (you).
+          This returns the same information as the 'help' command in Ruboty.
+
+          # Hint
+
+          - You are a Ruboty bot. You can find available commands by using this tool.
+          - If user asks for what you can do or usage (e.g. "Tell me the usage", "How do I use it?"), use this tool to respond.
+          - If user asks for specific commands, use the 'filter' argument to search for them.
+          - If user typed a command that you don't know, use this tool to find out the correct command.
+        TEXT
+
+        self.tool_input_schema = {
+          type: 'object',
+          properties: {
+            filter: {
+              type: 'string',
+              description: 'Optional filter to search for specific commands (e.g., "mcp", "ai", "ping")'
+            }
+          },
+          required: []
+        }
+
+        # @rbs arguments: Hash[String, untyped]
+        # @rbs return: String?
+        def call(arguments)
+          filter = arguments['filter']
+
+          descriptions = filtered_descriptions(filter)
+
+          if descriptions.empty?
+            if filter
+              "No description matched to '#{filter}'"
+            else
+              'No commands available'
+            end
+          else
+            descriptions.join("\n")
+          end
+        end
+
+        private
+
+        # @rbs filter: String?
+        # @rbs return: Array[String]
+        def filtered_descriptions(filter)
+          descriptions = all_descriptions
+
+          if filter
+            descriptions.select! do |description|
+              description.include?(filter)
+            end
+          end
+
+          descriptions
+        end
+
+        # @rbs return: Array[String]
+        def all_descriptions
+          actions = Ruboty.actions.reject(&:hidden?)
+
+          # Sort by description for consistent ordering
+          sorted_actions = begin
+            actions.sort_by(&:description)
+          rescue ArgumentError
+            # Fallback if sorting fails (e.g., in tests with mocks)
+            actions
+          end
+
+          sorted_actions.map do |action|
+            prefix = ''
+            prefix += "#{request.message.robot.name} " unless action.all?
+            "#{prefix}#{action.pattern.inspect} - #{action.description}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/tool_definitions/fetch.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module Ruboty
+  module AiAgent
+    module ToolDefinitions
+      # Fetch and extract readable content from web pages using ruby-readability
+      class Fetch < Base
+        class FetchError < StandardError; end
+
+        self.tool_name = 'fetch'
+        self.tool_title = 'Fetch Web Page Content'
+
+        self.tool_description = <<~TEXT
+          Fetch and extract readable content from a web page using ruby-readability.
+          This tool downloads the HTML from a URL and extracts the main readable text,
+          filtering out navigation, ads, and other boilerplate content.
+        TEXT
+
+        self.tool_input_schema = {
+          type: 'object',
+          properties: {
+            url: {
+              type: 'string',
+              description: 'The URL of the web page to fetch.'
+            }
+          },
+          required: ['url']
+        }
+
+        class << self
+          # @rbs @available: bool
+
+          def avaliable!
+            @available = true
+          end
+
+          def not_avaliable!
+            @available = false
+          end
+
+          def available? #: boolish
+            @available
+          end
+        end
+
+        # @rbs arguments: Hash[String, untyped]
+        # @rbs return: String?
+        def call(arguments)
+          url = arguments['url']
+
+          return 'Error: Please provide a URL parameter.' unless url
+
+          url = normalize_url(url.to_s)
+          return 'Error: Invalid URL format.' unless valid_url?(url)
+
+          content = begin
+            fetch_content(url)
+          rescue StandardError => e
+            raise FetchError, e.message
+          end
+
+          readable_content = extract_readable_content(content)
+
+          if readable_content.strip.empty?
+            "No readable content found on the page: #{url}"
+          else
+            "Content from #{url}:\n\n#{readable_content}"
+          end
+        rescue FetchError => e
+          "Failed to fetch content from #{url}: #{e.message}"
+        end
+
+        private
+
+        # @rbs url: String
+        # @rbs return: String
+        def normalize_url(url)
+          url = url.strip
+          url = "https://#{url}" unless url.match?(%r{\Ahttps?://})
+          url
+        end
+
+        # @rbs url: String
+        # @rbs return: bool
+        def valid_url?(url)
+          uri = URI.parse(url)
+          return false unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+          return false if uri.host.nil?
+
+          true
+        rescue URI::InvalidURIError
+          false
+        end
+
+        # @rbs url: String
+        # @rbs return: String
+        def fetch_content(url)
+          uri = URI.parse(url)
+          host = uri.host
+          port = uri.port
+          raise 'Invalid URL: missing host' if host.nil?
+
+          http = Net::HTTP.new(host, port)
+          http.use_ssl = true if uri.scheme == 'https'
+          http.open_timeout = 10
+          http.read_timeout = 30
+
+          path = uri.path
+          path = '/' if path.nil? || path.empty?
+          request = Net::HTTP::Get.new(path)
+          request['User-Agent'] = 'Mozilla/5.0 (compatible; RubotyAI/1.0)'
+
+          response = http.request(request)
+
+          raise "HTTP error: #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+          response.body
+        end
+
+        # @rbs content: String
+        # @rbs return: String
+        def extract_readable_content(content)
+          document = Readability::Document.new(content)
+          document.content
+        end
+      end
+    end
+  end
+end
+
+# Add Fetch tool only if ruby-readability is available
+begin
+  require 'ruby-readability'
+  Ruboty::AiAgent::ToolDefinitions::Fetch.avaliable!
+rescue LoadError
+  # ruby-readability not available, skip Fetch tool
+  Ruboty::AiAgent::ToolDefinitions::Fetch.not_avaliable!
+end

data/lib/ruboty/ai_agent/tool_definitions/think.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module ToolDefinitions
+      # Tool
+      class Think < Base
+        self.tool_name = 'think'
+        self.tool_title = 'Think'
+
+        self.tool_description = <<~TEXT
+          Use this tool to think abount something. It will not obtain new information or make any changes, but just log the thought.
+          Use it when completx reasoing or brainstorming is needed.
+        TEXT
+
+        self.tool_input_schema = {
+          type: 'object',
+          properties: {
+            thought: { type: 'string', description: 'Your thought.' }
+          },
+          required: ['thought']
+        }
+
+        # @rbs arguments: Hash[String, untyped]
+        # @rbs return: String?
+        def call(arguments)
+          thought = arguments['thought']
+
+          request.message.reply("Thought:\n#{thought}")
+
+          thought
+        end
+
+        # @rbs override
+        def silent?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/tool_definitions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Tool Definitions for AI Agent
+    module ToolDefinitions
+      autoload :Base, 'ruboty/ai_agent/tool_definitions/base'
+      autoload :Fetch, 'ruboty/ai_agent/tool_definitions/fetch'
+      autoload :Think, 'ruboty/ai_agent/tool_definitions/think'
+      autoload :BotHelp, 'ruboty/ai_agent/tool_definitions/bot_help'
+
+      # @rbs request: Request
+      # @rbs return: Array[Base]
+      def self.builtins(request:)
+        [
+          Think,
+          BotHelp,
+          Fetch
+        ].select(&:available?).map { |tool_def| tool_def.new(request:) }
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/user_mcp_client.rb

@@ -68,14 +68,15 @@ module Ruboty
         mcp_client.cleanup_session
       end
 
-      private
-
       # @rbs return: McpConfiguration
       def configuration
         user.mcp_configurations.all_values.find { |config| config.name == mcp_name } ||
           raise("MCP configuration not found: #{mcp_name}")
       end
 
+      private
+
+      # @rbs %a{memorized}
       # @rbs return: HttpMcpClient
       def mcp_client
         @mcp_client ||= case configuration.transport

data/lib/ruboty/ai_agent/version.rb

@@ -2,6 +2,6 @@
 
 module Ruboty
   module AiAgent
-    VERSION = '0.2.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/ruboty/ai_agent.rb

@@ -28,8 +28,11 @@ module Ruboty
     autoload :PromptCommandDefinition, 'ruboty/ai_agent/prompt_command_definition'
     autoload :Recordable, 'ruboty/ai_agent/recordable'
     autoload :RecordSet, 'ruboty/ai_agent/record_set'
+    autoload :Request, 'ruboty/ai_agent/request'
+    autoload :Settings, 'ruboty/ai_agent/settings'
     autoload :TokenUsage, 'ruboty/ai_agent/token_usage'
     autoload :Tool, 'ruboty/ai_agent/tool'
+    autoload :ToolDefinitions, 'ruboty/ai_agent/tool_definitions'
     autoload :User, 'ruboty/ai_agent/user'
     autoload :UserAiMemories, 'ruboty/ai_agent/user_ai_memories'
     autoload :UserAssociations, 'ruboty/ai_agent/user_associations'
@@ -39,6 +42,8 @@ module Ruboty
     autoload :UserMcpToolsCaches, 'ruboty/ai_agent/user_mcp_tools_caches'
     autoload :UserPromptCommandDefinitions, 'ruboty/ai_agent/user_prompt_command_definitions'
 
+    extend Settings::Accessor
+
     # Ensure all recordables are loaded
     [
       CachedValue,

data/lib/ruboty/handlers/ai_agent.rb

@@ -9,6 +9,9 @@ module Ruboty
       env :OPENAI_API_KEY, 'Pass your OpenAI API Key'
       env :OPENAI_MODEL, 'OpenAI model to use', optional: true
 
+      env :AI_AGENT_MAX_TOKENS, 'Max tokens for AI requests (For OpenAI Models, the default value is automatically decided)', optional: true
+      env :AI_AGENT_AUTO_COMPACT_THRESHOLD, 'Threshold of token usage in percentage to auto compact AI memory (default: 90)', optional: true
+
       on(
         /(?<body>.+)/m,
         description: 'AI responds to your message if given message did not match any other handlers',
@@ -18,7 +21,7 @@ module Ruboty
 
       on(/add mcp (?<name>\S+)\s+(?<config>.+)\z/, name: 'add_mcp', description: 'Add a new MCP server')
       on(/remove mcp (?<name>\S+)/, name: 'remove_mcp', description: 'Remove the specified MCP server')
-      on(/list mcps?/, name: 'list_mcp', description: 'List configured MCP servers')
+      on(/list mcps?(?<with_headers>\s+with\s+headers)?/, name: 'list_mcp', description: 'List configured MCP servers')
 
       on(/set (?:(?<scope>user|global) )?system prompt "(?<prompt>.+?)"/, name: 'set_system_prompt', description: 'Set system prompt')
       on(/show system prompt/, name: 'show_system_prompt', description: 'Show system prompt')

data/script/generate-memorized-ivar-rbs.rb

@@ -40,7 +40,7 @@ require 'fileutils'
 # Generate RBS instance variable definitions for memorized methods
 class MemorizedIvarRbsGenerator
   Source = Data.define(:file, :content, :prism_node)
-  MemorizedMethod = Data.define(:class_name, :method_name, :ivar_name, :return_type, :file)
+  MemorizedMethod = Data.define(:class_name, :method_name, :ivar_name, :return_type, :file, :is_class_ivar)
 
   def initialize(lib_path: 'lib', output_path: 'sig/generated-by-scripts', namespace_filter: nil)
     @lib_path = Pathname(lib_path)
@@ -58,7 +58,8 @@ class MemorizedIvarRbsGenerator
 
     puts "Found #{memorized_methods.size} memorized methods:"
     memorized_methods.each do |method|
-      puts "  - #{method.class_name}##{method.method_name} -> @#{method.ivar_name}: #{method.return_type}"
+      prefix = method.is_class_ivar ? '.' : '#'
+      puts "  - #{method.class_name}#{prefix}#{method.method_name} -> @#{method.ivar_name}: #{method.return_type}"
     end
 
     generate_rbs_files(memorized_methods)
@@ -108,10 +109,20 @@ class MemorizedIvarRbsGenerator
       # Class declaration with instance variables
       content << (('  ' * indent_level) + "class #{parts.last}")
 
-      methods.each do |method|
+      # Separate instance variables and class instance variables
+      instance_methods = methods.reject(&:is_class_ivar)
+      class_methods = methods.select(&:is_class_ivar)
+
+      # Add instance variables
+      instance_methods.each do |method|
         content << (('  ' * (indent_level + 1)) + "@#{method.ivar_name}: #{method.return_type}")
       end
 
+      # Add class instance variables (using self.@variable_name notation)
+      class_methods.each do |method|
+        content << (('  ' * (indent_level + 1)) + "self.@#{method.ivar_name}: #{method.return_type}")
+      end
+
       content << "#{'  ' * indent_level}end"
 
       # Close namespaces
@@ -138,6 +149,7 @@ class MemorizedIvarRbsGenerator
       @memorized_methods = []
       @namespace = []
       @current_class = nil
+      @in_singleton_class = false
       super()
     end
 
@@ -157,12 +169,22 @@ class MemorizedIvarRbsGenerator
       end
     end
 
+    def visit_singleton_class_node(node)
+      old_singleton = @in_singleton_class
+      @in_singleton_class = true
+      super
+      @in_singleton_class = old_singleton
+    end
+
     def visit_def_node(node)
       return unless @current_class
 
       # Skip if namespace filter is set and doesn't match
       return if @namespace_filter && !@current_class.start_with?(@namespace_filter)
 
+      # Check if it's a class method (def self.method_name)
+      is_class_method = node.receiver&.is_a?(Prism::SelfNode)
+
       # Check for memorized annotation
       if memorized_annotated?(node)
         method_name = node.name.to_s
@@ -176,7 +198,8 @@ class MemorizedIvarRbsGenerator
             method_name: method_name,
             ivar_name: ivar_info[:ivar_name],
             return_type: ivar_info[:return_type],
-            file: source.file
+            file: source.file,
+            is_class_ivar: @in_singleton_class || is_class_method
           )
         end
       end

data/sig/generated/ruboty/ai_agent/actions/base.rbs

@@ -28,6 +28,10 @@ module Ruboty
         # @rbs %a{memorized}
         %a{memorized}
         def chat_thread: () -> Ruboty::AiAgent::ChatThread
+
+        private
+
+        def thread_id: () -> String
       end
     end
   end

data/sig/generated/ruboty/ai_agent/actions/chat.rbs

@@ -12,11 +12,19 @@ module Ruboty
 
         def body_param: () -> String
 
+        # @rbs %a{memorized}
+        %a{memorized}
+        def request: () -> Request
+
         private
 
         # @rbs body: String
         # @rbs return: void
         def complete_chat: (String body) -> void
+
+        def truncate: (untyped text, max: untyped) -> untyped
+
+        def indent_with_quotation: (untyped text, ?untyped quota) -> untyped
       end
     end
   end

data/sig/generated/ruboty/ai_agent/actions/list_mcp.rbs

@@ -6,6 +6,17 @@ module Ruboty
       # ListMcp action for Ruboty::AiAgent
       class ListMcp < Base
         def call: () -> untyped
+
+        private
+
+        # @rbs client: UserMcpClient
+        # @rbs show_headers: bool
+        # @rbs return: String
+        def format_mcp_client: (UserMcpClient client, ?show_headers: bool) -> String
+
+        # @rbs client: UserMcpClient
+        # @rbs return: String
+        def format_tools: (UserMcpClient client) -> String
       end
     end
   end

data/sig/generated/ruboty/ai_agent/agent.rbs

@@ -21,7 +21,7 @@ module Ruboty
 
       def on_tool_call: (tool: untyped, tool_arguments: untyped) ?{ (?) -> untyped } -> untyped
 
-      def on_tool_response: (tool_response: untyped, message: untyped) ?{ (?) -> untyped } -> untyped
+      def on_tool_response: (tool: untyped, tool_response: untyped, message: untyped) ?{ (?) -> untyped } -> untyped
 
       def on_response: (untyped response) ?{ (?) -> untyped } -> untyped
     end

data/sig/generated/ruboty/ai_agent/chat_thread_messages.rbs

@@ -7,11 +7,12 @@ module Ruboty
       # @rbs message: ChatMessage
       def add: (ChatMessage message) -> void
 
+      def token_usage: () -> TokenUsage?
+
       alias << add
 
       # Check if any message's token usage exceeds auto compact threshold
-      # @rbs return: bool
-      def over_auto_compact_threshold?: () -> bool
+      def over_auto_compact_threshold?: () -> boolish
 
       # Compact chat messages by summarizing them
       # @rbs llm: LLM::OpenAI

data/sig/generated/ruboty/ai_agent/commands/base.rbs

@@ -6,13 +6,14 @@ module Ruboty
       # Base class for commands.
       # @abstract
       class Base
-        attr_reader message: Ruboty::Message
+        attr_reader request: Request
 
-        attr_reader chat_thread: Ruboty::AiAgent::ChatThread
+        # @rbs request: Request
+        def initialize: (request: Request) -> untyped
 
-        # @rbs message: Ruboty::Message
-        # @rbs chat_thread: Ruboty::AiAgent::ChatThread
-        def initialize: (message: Ruboty::Message, chat_thread: Ruboty::AiAgent::ChatThread) -> untyped
+        def message: () -> Ruboty::Message
+
+        def chat_thread: () -> Ruboty::AiAgent::ChatThread
 
         # @rbs *args: untyped
         # @rbs return: untyped

data/sig/generated/ruboty/ai_agent/commands/prompt_command.rbs

@@ -8,9 +8,8 @@ module Ruboty
         attr_reader definition: Ruboty::AiAgent::PromptCommandDefinition
 
         # @rbs definition: Ruboty::AiAgent::PromptCommandDefinition
-        # @rbs message: Ruboty::Message
-        # @rbs chat_thread: Ruboty::AiAgent::ChatThread
-        def initialize: (definition: Ruboty::AiAgent::PromptCommandDefinition, message: Ruboty::Message, chat_thread: Ruboty::AiAgent::ChatThread) -> untyped
+        # @rbs request: Ruboty::AiAgent::Request
+        def initialize: (definition: Ruboty::AiAgent::PromptCommandDefinition, request: Ruboty::AiAgent::Request) -> untyped
 
         # @rbs commandline: String
         # @rbs return: boolish

data/sig/generated/ruboty/ai_agent/commands.rbs

@@ -4,10 +4,9 @@ module Ruboty
   module AiAgent
     # Interaction commands (a.k.a. Slash commands, Prompts, etc)
     module Commands
-      # @rbs message: Ruboty::Message
-      # @rbs chat_thread: ChatThread
+      # @rbs request: Request
       # @rbs return: Array[Commands::BuiltinBase]
-      def self.builtins: (message: Ruboty::Message, chat_thread: ChatThread) -> Array[Commands::BuiltinBase]
+      def self.builtins: (request: Request) -> Array[Commands::BuiltinBase]
     end
   end
 end

data/sig/generated/ruboty/ai_agent/mcp_clients.rbs

@@ -12,11 +12,6 @@ module Ruboty
       # @rbs return: Array[Tool]
       def available_tools: () -> Array[Tool]
 
-      # @rbs function_name: String
-      # @rbs arguments: Hash[String, untyped]
-      # @rbs return: untyped
-      def execute_tool: (String function_name, Hash[String, untyped] arguments) -> untyped
-
       # @rbs return: bool
       def any?: () -> bool
     end

data/sig/generated/ruboty/ai_agent/request.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/ruboty/ai_agent/request.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    class Request < Data
+      attr_reader message(): Ruboty::Message
+
+      attr_reader chat_thread(): Ruboty::AiAgent::ChatThread
+
+      def self.new: (Ruboty::Message message, Ruboty::AiAgent::ChatThread chat_thread) -> instance
+                  | (message: Ruboty::Message, chat_thread: Ruboty::AiAgent::ChatThread) -> instance
+
+      def self.members: () -> [ :message, :chat_thread ]
+
+      def members: () -> [ :message, :chat_thread ]
+    end
+
+    # Request for chat action from user.
+    class Request
+      def message_body: () -> String
+    end
+  end
+end

data/sig/generated/ruboty/ai_agent/settings.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/ruboty/ai_agent/settings.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    # Provide library-wide settings.
+    class Settings
+      # Provide access to settings instance.
+      module Accessor
+        def settings: () -> Ruboty::AiAgent::Settings
+      end
+
+      # @rbs %a{memorized}
+      %a{memorized}
+      def self.instance: () -> Ruboty::AiAgent::Settings
+
+      def max_tokens: () -> Integer?
+
+      def auto_compact_threshold: () -> Float
+    end
+  end
+end

data/sig/generated/ruboty/ai_agent/tool.rbs

@@ -12,14 +12,20 @@ module Ruboty
 
       attr_reader input_schema: Hash[untyped, untyped]?
 
-      attr_reader on_call: (^(Hash[String, untyped]) -> String)?
+      attr_reader silent: boolish
+
+      attr_reader on_call: (^(Hash[String, untyped]) -> String?)?
 
       # @rbs name: String
       # @rbs title: String
       # @rbs description: String
       # @rbs input_schema: Hash[untyped, untyped]?
-      # @rbs &on_call: ? (Hash[String, untyped]) -> String
-      def initialize: (name: String, title: String, description: String, input_schema: Hash[untyped, untyped]?) ?{ (Hash[String, untyped]) -> String } -> void
+      # @rbs ?silent: boolish?
+      # @rbs &on_call: ? (Hash[String, untyped]) -> String?
+      def initialize: (name: String, title: String, description: String, input_schema: Hash[untyped, untyped]?, ?silent: untyped) ?{ (Hash[String, untyped]) -> String? } -> void
+
+      # Returns true if the tool should be called silently (without notifying the user).
+      def silent?: () -> boolish
 
       def call: (untyped params) -> String?
     end