ruboty-ai_agent 0.1.0 → 0.3.0

data/lib/ruboty/ai_agent/commands/compact.rb

@@ -4,30 +4,16 @@ module Ruboty
   module AiAgent
     module Commands
       # Compact chat history by summarizing it
-      class Compact < Base
+      class Compact < BuiltinBase
         on(%r{/compact}, name: 'compact', description: 'Compact the chat history by summarizing it.')
 
-        attr_reader :message #: Ruboty::Message
-        attr_reader :chat_thread #: Ruboty::AiAgent::ChatThread
-
-        # @rbs message: Ruboty::Message
-        # @rbs chat_thread: Ruboty::AiAgent::ChatThread
-        def initialize(message:, chat_thread:)
-          @message = message
-          @chat_thread = chat_thread
-
-          super()
-        end
-
-        def call #: void
-          messages = chat_thread.messages.all_values
-
-          if messages.empty?
+        def call(*) #: void
+          if chat_thread.messages.empty?
             message.reply('No chat history to compact.')
             return
           end
 
-          summary = generate_summary(messages)
+          summary = chat_thread.messages.summarize(llm: LLM::OpenAI.new)
 
           chat_thread.clear
           chat_thread.messages.add(
@@ -45,35 +31,6 @@ module Ruboty
             message.reply("エラーが発生しました: #{e.message}")
           end
         end
-
-        private
-
-        # @rbs messages: Array[ChatMessage]
-        # @rbs return: String
-        def generate_summary(messages)
-          llm = LLM::OpenAI.new(
-            client: OpenAI::Client.new(
-              api_key: ENV.fetch('OPENAI_API_KEY', nil)
-            ),
-            model: ENV.fetch('OPENAI_MODEL', 'gpt-5-nano')
-          )
-
-          summary_prompt = ChatMessage.new(
-            role: :user,
-            content: "Please summarize the following conversation in a concise manner, capturing the key topics, decisions, and context that would be helpful for continuing the conversation:\n\n#{format_messages_for_summary(messages)}"
-          )
-
-          response = llm.complete(messages: [summary_prompt])
-          response.message.content
-        end
-
-        # @rbs messages: Array[ChatMessage]
-        # @rbs return: String
-        def format_messages_for_summary(messages)
-          messages.map do |msg|
-            "#{msg.role}: #{msg.content}"
-          end.join("\n")
-        end
       end
     end
   end

data/lib/ruboty/ai_agent/commands/prompt_command.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Ruboty
+  module AiAgent
+    module Commands
+      # Compact chat history by summarizing it
+      class PromptCommand < Base
+        attr_reader :definition #: Ruboty::AiAgent::PromptCommandDefinition
+
+        # @rbs definition: Ruboty::AiAgent::PromptCommandDefinition
+        # @rbs request: Ruboty::AiAgent::Request
+        def initialize(definition:, request:)
+          @definition = definition
+
+          super(request:)
+        end
+
+        # @rbs commandline: String
+        # @rbs return: boolish
+        def match?(commandline)
+          pattern.match?(commandline)
+        end
+
+        def pattern #: Regexp
+          %r{\A\s*/#{definition.name}(?:\s+(?<args>.+))?}
+        end
+
+        # @rbs commandline: String
+        # @rbs return: String
+        def call(commandline:)
+          result = definition.prompt.dup
+
+          match = pattern.match(commandline) || (raise 'Unreachable')
+          args = begin
+            Shellwords.split(match[:args] || '')
+          rescue ArgumentError
+            # If parsing fails, treat the entire string as a single argument
+            [match[:args]].compact
+          end #: Array[String]
+
+          found = {} #: Hash[Integer, boolish]
+          args.each_with_index do |arg, index|
+            placeholder = "$#{index + 1}"
+            result = result.gsub(placeholder) do
+              found[index] = true
+              arg
+            end
+          end
+
+          rest_args = args.each_with_index.reject { |_, index| found[index] }.map(&:first)
+          result += "\n\n#{rest_args.join(' ')}" if rest_args.any?
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/commands/usage.rb

@@ -4,22 +4,10 @@ module Ruboty
   module AiAgent
     module Commands
       # Show token usage information for the latest AI response
-      class Usage < Base
+      class Usage < BuiltinBase
         on(%r{/usage}, name: 'show_usage', description: 'Show token usage information for the latest AI response')
 
-        attr_reader :message #: Ruboty::Message
-        attr_reader :chat_thread #: Ruboty::AiAgent::ChatThread
-
-        # @rbs message: Ruboty::Message
-        # @rbs chat_thread: Ruboty::AiAgent::ChatThread
-        def initialize(message:, chat_thread:)
-          @message = message
-          @chat_thread = chat_thread
-
-          super()
-        end
-
-        def call #: void
+        def call(*) #: void
           latest_message = chat_thread.messages.all_values.find(&:token_usage)
 
           token_usage = latest_message&.token_usage

data/lib/ruboty/ai_agent/commands.rb

@@ -5,28 +5,20 @@ module Ruboty
     # Interaction commands (a.k.a. Slash commands, Prompts, etc)
     module Commands
       autoload :Base, 'ruboty/ai_agent/commands/base'
+      autoload :BuiltinBase, 'ruboty/ai_agent/commands/builtin_base'
       autoload :Clear, 'ruboty/ai_agent/commands/clear'
       autoload :Compact, 'ruboty/ai_agent/commands/compact'
       autoload :Usage, 'ruboty/ai_agent/commands/usage'
+      autoload :PromptCommand, 'ruboty/ai_agent/commands/prompt_command'
 
-      # @rbs message: Ruboty::Message
-      # @rbs chat_thread: ChatThread
-      # @rbs return: Array[Commands::Base]
-      def self.builtins(message:, chat_thread:)
+      # @rbs request: Request
+      # @rbs return: Array[Commands::BuiltinBase]
+      def self.builtins(request:)
         [
-          Commands::Clear.new(
-            message:,
-            chat_thread:
-          ),
-          Commands::Compact.new(
-            message:,
-            chat_thread:
-          ),
-          Commands::Usage.new(
-            message:,
-            chat_thread:
-          )
-        ]
+          Commands::Clear,
+          Commands::Compact,
+          Commands::Usage
+        ].map { |cmd_class| cmd_class.new(request: request) }
       end
     end
   end

data/lib/ruboty/ai_agent/database/query_methods.rb

@@ -7,27 +7,49 @@ module Ruboty
       #   interface _WithData
       #     def data: -> Hash[keynable, untyped]
       #   end
+      #
+      #   type query_key = keynable | Symbol | nil
 
       # @rbs module-self _WithData
       module QueryMethods
-        # @rbs *keys: keynable
+        # @rbs keys: Array[query_key]
+        # @rbs return: Array[keynable]
+        def self.keys_to_keynable(keys)
+          keys.map do |k|
+            case k
+            when String, Symbol
+              k.to_s
+            when Integer
+              k
+            when NilClass
+              ''
+            else
+              raise ArgumentError, "Invalid key type: #{k.class}"
+            end
+          end
+        end
+
+        # @rbs *keys: query_key
         # @rbs return: untyped
         def fetch(*keys)
+          keys = QueryMethods.keys_to_keynable(keys)
           item = data.dig(*keys)
 
           Recordable.instantiate_recursively(item)
         end
 
-        # @rbs *keys: keynable
+        # @rbs *keys: query_key
         # @rbs return: Integer
         def len(*keys)
+          keys = QueryMethods.keys_to_keynable(keys)
           item = data.dig(*keys)
           item.respond_to?(:length) ? item.length : 0
         end
 
-        # @rbs *keys: keynable
+        # @rbs *keys: query_key
         # @rbs return: void
         def delete(*keys)
+          keys = QueryMethods.keys_to_keynable(keys)
           namespace_keys = keys[0..-2] || []
           key = keys[-1]
 
@@ -40,9 +62,10 @@ module Ruboty
           end
         end
 
-        # @rbs *keys: keynable
+        # @rbs *keys: query_key
         # @rbs return: Array[keynable]
         def keys(*keys)
+          keys = QueryMethods.keys_to_keynable(keys)
           namespace = keys.empty? ? data : data.dig(*keys) #: top
           case namespace
           when Hash
@@ -54,9 +77,10 @@ module Ruboty
           end
         end
 
-        # @rbs *keys: keynable
+        # @rbs *keys: query_key
         # @rbs return: boolish
         def key?(*keys)
+          keys = QueryMethods.keys_to_keynable(keys)
           namespace_keys = keys[0..-2] || []
           key = keys[-1]
 
@@ -64,10 +88,11 @@ module Ruboty
           namespace&.key?(key)
         end
 
-        # @rbs at: Array[keynable]
+        # @rbs at: Array[query_key]
         # @rbs value: untyped
         # @rbs return: void
         def store(value, at:)
+          at = QueryMethods.keys_to_keynable(at)
           namespace_keys = at[0..-2] || []
           key = at[-1]
 

data/lib/ruboty/ai_agent/database.rb

@@ -5,7 +5,7 @@ module Ruboty
     # Memorize and retrieve information using Ruboty's brain.
     class Database
       # @rbs!
-      #   type keynable = Symbol | String | Integer
+      #   type keynable = String | Integer
 
       autoload :QueryMethods, 'ruboty/ai_agent/database/query_methods'
 
@@ -32,6 +32,7 @@ module Ruboty
         ChatThread.find_or_create(database: self, id: id)
       end
 
+      # @rbs %a{memorized}
       def global_settings #: GlobalSettings
         @global_settings ||= GlobalSettings.find_or_create(database: self)
       end

data/lib/ruboty/ai_agent/http_mcp_client.rb

@@ -51,7 +51,7 @@ module Ruboty
 
       # @rbs name: String
       # @rbs &block: ? (Hash[String, untyped]) -> void
-      def call_tool(name, arguments = {}, &block)
+      def call_tool(name, arguments = {}, &)
         ensure_initialized
         results = send_request(
           method: 'tools/call',
@@ -59,7 +59,7 @@ module Ruboty
             name: name,
             arguments: arguments
           },
-          &block
+          &
         )
 
         results.flat_map { |res| res.dig('result', 'content') || [] }
@@ -166,6 +166,9 @@ module Ruboty
         else
           handle_response(response, &block)
         end
+      rescue Net::HTTPExceptions, SystemCallError => e
+        error_message = e.is_a?(StandardError) ? e.message : "Unknown error (#{e.class.name})"
+        raise Error, "HTTP request failed: #{error_message}"
       end
 
       # @rbs response: Net::HTTPResponse

data/lib/ruboty/ai_agent/llm/openai.rb

@@ -11,11 +11,11 @@ module Ruboty
         attr_reader :client #: OpenAI::Client
         attr_reader :model #: String
 
-        # @rbs client: OpenAI::Client
-        # @rbs model: String
-        def initialize(client:, model:)
-          @client = client
-          @model = model
+        # @rbs ?client: OpenAI::Client
+        # @rbs ?model: String
+        def initialize(client: nil, model: nil)
+          @client = client || ::OpenAI::Client.new(api_key: ENV.fetch('OPENAI_API_KEY', nil))
+          @model = model || ENV.fetch('OPENAI_MODEL', 'gpt-5-nano')
         end
 
         # @rbs %a{memorized}
@@ -158,7 +158,7 @@ module Ruboty
                 tool_call #: OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall
                 .function.arguments
 
-              JSON.parse(arguments, { symbolize_names: true })
+              JSON.parse(arguments)
             end
 
           Response.new(

data/lib/ruboty/ai_agent/mcp_clients.rb

@@ -16,8 +16,9 @@ module Ruboty
         clients.flat_map do |client|
           tool_defs = client.list_tools
           tool_defs.map do |tool_def|
+            tool_name = "mcp_#{client.mcp_name}__#{tool_def['name']}"
             Tool.new(
-              name: tool_def['name'],
+              name: tool_name,
               title: tool_def['title'] || '',
               description: tool_def['description'] || '',
               input_schema: tool_def['inputSchema']
@@ -25,20 +26,12 @@ module Ruboty
               client.call_tool(tool_def['name'], params).to_json
             end
           end
+        rescue HttpMcpClient::Error => e
+          warn "Failed to list tools for MCP client: #{e.message}"
+          []
         end
       end
 
-      # @rbs function_name: String
-      # @rbs arguments: Hash[String, untyped]
-      # @rbs return: untyped
-      def execute_tool(function_name, arguments)
-        clients.each do |mcp_client|
-          tools = mcp_client.list_tools
-          return mcp_client.call_tool(function_name, arguments) if tools.any? { |t| t['name'] == function_name }
-        end
-        nil
-      end
-
       # @rbs return: bool
       def any?
         @clients.any?

data/lib/ruboty/ai_agent/mcp_configuration.rb

@@ -4,6 +4,7 @@ module Ruboty
   module AiAgent
     # @rbs!
     #   type transports = :http | :websocket
+    #   type transports_str = "http" | "websocket"
 
     McpConfiguration = Data.define(
       :name, #: String
@@ -17,12 +18,12 @@ module Ruboty
       include Recordable
 
       # @rbs name: String
-      # @rbs transport: transports
+      # @rbs transport: transports | transports_str
       # @rbs url: String
       # @rbs headers: Hash[String, String]?
       def initialize(name:, transport:, url:, headers: {})
         # No superclass method `initialize` in RBS.
-        super(name:, transport:, headers:, url:) # steep:ignore UnexpectedKeywordArgument
+        super(name:, transport: transport.to_sym, headers:, url:) # steep:ignore UnexpectedKeywordArgument
       end
 
       register_record_type :mcp_configuration

data/lib/ruboty/ai_agent/prompt_command_definition.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    PromptCommandDefinition = Data.define(
+      :name, #: String
+      :prompt #: String
+    )
+
+    # User-defined command model
+    class PromptCommandDefinition
+      include Recordable
+
+      register_record_type :user_defined_command
+    end
+  end
+end

data/lib/ruboty/ai_agent/record_set.rb

@@ -11,10 +11,14 @@ module Ruboty
         @database = database
       end
 
-      def namespace_keys #: Array[Database::keynable]
+      def namespace_keys #: Array[Database::query_key]
         raise NotImplementedError, 'Subclasses must implement the namespace_keys method'
       end
 
+      def empty? #: boolish
+        length.zero?
+      end
+
       def length #: Integer
         database.len(*namespace_keys)
       end
@@ -38,26 +42,26 @@ module Ruboty
         database.keys(*namespace_keys)
       end
 
-      # @rbs key: Database::keynable
+      # @rbs key: Database::query_key
       # @rbs return: Record | nil
       def fetch(key)
         database.fetch(*namespace_keys, key)
       end
 
-      # @rbs key: Database::keynable
+      # @rbs key: Database::query_key
       # @rbs record: Record
       # @rbs return: void
       def store(record, key:)
         database.store(record, at: [*namespace_keys, key])
       end
 
-      # @rbs key: Database::keynable
+      # @rbs key: Database::query_key
       # @rbs return: void
       def remove(key)
         database.delete(*namespace_keys, key)
       end
 
-      # @rbs key: Database::keynable
+      # @rbs key: Database::query_key
       # @rbs return: boolish
       def key?(key)
         database.key?(*namespace_keys, key)

data/lib/ruboty/ai_agent/recordable.rb

@@ -4,7 +4,7 @@ module Ruboty
   module AiAgent
     # @rbs!
     #   interface _WithToH
-    #     def to_h: () -> Hash[Database::keynable, untyped]
+    #     def to_h: () -> Hash[Symbol, untyped]
     #   end
 
     # Convertable between Hash and Recordable bidirectionally.
@@ -22,12 +22,12 @@ module Ruboty
           @record_types ||= {}
         end
 
-        # @rbs hash: Hash[Symbol, untyped]?
+        # @rbs hash: Hash[Symbol | String, untyped]?
         # @rbs return: bool
         def convertable?(hash)
           return false unless hash.is_a?(Hash)
 
-          type = hash[:record_type]
+          type = (hash[:record_type] || hash['record_type'])&.to_sym
           type && record_types.include?(type)
         end
 
@@ -54,9 +54,9 @@ module Ruboty
         def hashify_recursively(value)
           case value
           when Recordable
-            hashify_recursively(value.to_h)
+            hashify_recursively(record_to_hash(value))
           when Hash
-            value.transform_values { |v| hashify_recursively(v) }
+            value.transform_values { |v| hashify_recursively(v) }.transform_keys(&:to_s)
           when Array
             value.map { |v| hashify_recursively(v) }
           else
@@ -67,13 +67,15 @@ module Ruboty
         # @rbs record: Recordable
         # @rbs return: Hash[Database::keynable, untyped]
         def record_to_hash(record)
-          record.to_h
+          record.to_h.transform_keys(&:to_s)
         end
 
-        # @rbs hash: Hash[Symbol, untyped]
+        # @rbs hash: Hash[Symbol | String, untyped]
         # @rbs return: Recordable
         def record_from_hash(hash)
-          type = hash[:record_type]
+          hash = hash.transform_keys(&:to_sym)
+
+          type = hash[:record_type]&.to_sym
           klass = record_types[type]
           raise "Unknown record type: #{type}" unless klass
 
@@ -98,7 +100,7 @@ module Ruboty
 
       # @rbs module-self Recordable::ClassMethods.instance
       module PrependMethods
-        def to_h #: Hash[Database::keynable, untyped]
+        def to_h #: Hash[Symbol, untyped]
           {
             record_type: record_type,
             **super

data/lib/ruboty/ai_agent/request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    Request = Data.define(
+      :message, #: Ruboty::Message
+      :chat_thread #: Ruboty::AiAgent::ChatThread
+    )
+
+    # Request for chat action from user.
+    class Request
+      def message_body #: String
+        message[:body]
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/token_usage.rb

@@ -32,6 +32,16 @@ module Ruboty
         (total_tokens.to_f / token_limit * 100).round(2).to_f
       end
 
+      # Check if usage percentage exceeds auto compact threshold
+      # @rbs return: bool
+      def over_auto_compact_threshold?
+        percentage = usage_percentage
+        return false unless percentage
+
+        threshold = ENV.fetch('AUTO_COMPACT_THRESHOLD', 80).to_f
+        percentage >= threshold
+      end
+
       def to_h #: Hash[Symbol, untyped]
         {
           prompt_tokens:,

data/lib/ruboty/ai_agent/tool.rb

@@ -6,21 +6,29 @@ module Ruboty
     class Tool
       attr_reader :name, :title, :description #: String
       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:, title:, description:, input_schema:, &on_call) #: void
+      # @rbs ?silent: boolish?
+      # @rbs &on_call: ? (Hash[String, untyped]) -> String?
+      def initialize(name:, title:, description:, input_schema:, silent: false, &on_call) #: void
         @name = name
         @title = title
         @description = description
         @input_schema = input_schema
+        @silent = silent
         @on_call = on_call
       end
 
+      # Returns true if the tool should be called silently (without notifying the user).
+      def silent? #: boolish
+        silent
+      end
+
       def call(params) #: String?
         on_call&.call(params)
       end