ruboty-ai_agent 0.1.0

data/lib/ruboty/ai_agent/actions/list_ai_commands.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ListAiCommands action for Ruboty::AiAgent
+      class ListAiCommands < Base
+        # @rbs override
+        def call
+          commands = Commands.builtins(message:, chat_thread:)
+
+          message.reply(
+            commands.flat_map(&:matchers).map { |matcher| "#{matcher.pattern.inspect} - #{matcher.description}" }.join("\n")
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/list_ai_memories.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ListAiMemories action for Ruboty::AiAgent
+      class ListAiMemories < Base
+        def call
+          memories = (user.ai_memories.all || {}).map do |idx, memory|
+            "Memory #{idx}: #{memory}"
+          end.join("\n")
+
+          message.reply(memories.empty? ? 'No memories found.' : memories)
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/list_mcp.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ListMcp action for Ruboty::AiAgent
+      class ListMcp < Base
+        def call
+          mcp_configurations = (user.mcp_configurations.all || {}).map do |name, mcp_configuration|
+            "#{name}: #{mcp_configuration.to_h.except(:record_type).to_json}"
+          end.join("\n")
+
+          message.reply(mcp_configurations.empty? ? 'No memories found.' : mcp_configurations)
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/remove_ai_command.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # RemoveAiCommand action for Ruboty::AiAgent
+      class RemoveAiCommand < Base
+        def call
+          message.reply("TODO: Implement RemoveAiCommand action for name: #{name_param}")
+        end
+
+        def name_param #: String
+          message[:name]
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/remove_ai_memory.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # RemoveAiMemory action for Ruboty::AiAgent
+      class RemoveAiMemory < Base
+        def call
+          message.reply("TODO: Implement RemoveAiMemory action for index: #{index_param}")
+          if user.ai_memories.key?(index_param)
+            user.ai_memories.remove(index_param)
+
+            message.reply("Removed memory #{index_param}.")
+          else
+            message.reply("Memory #{index_param} does not exist.")
+          end
+        end
+
+        def index_param #: String
+          message[:index]
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/remove_mcp.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # RemoveMcp action for Ruboty::AiAgent
+      class RemoveMcp < Base
+        def call
+          if user.mcp_configurations.key?(name_param)
+            user.mcp_configurations.remove(name_param)
+
+            message.reply("Removed MCP configuration #{name_param}.")
+          else
+            message.reply("MCP configuration #{name_param} does not exist.")
+          end
+        end
+
+        def name_param #: String
+          message[:name]
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/set_system_prompt.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # SetSystemPrompt action for Ruboty::AiAgent
+      class SetSystemPrompt < Base
+        def call
+          case scope_param.to_sym
+          when :user
+            user.system_prompt = prompt_param
+            message.reply("Set user system prompt: #{prompt_param}")
+          when :global
+            database.global_settings.system_prompt = prompt_param
+            message.reply("Set global system prompt: #{prompt_param}")
+          else
+            message.reply("Error: Invalid scope '#{scope_param}'. Use 'user' or 'global'.")
+          end
+        end
+
+        def prompt_param #: String
+          message[:prompt]
+        end
+
+        def scope_param #: String
+          message[:scope] || 'user'
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions/show_system_prompt.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ShowSystemPrompt action for Ruboty::AiAgent
+      class ShowSystemPrompt < Base
+        def call
+          user_prompt = user.system_prompt
+          global_prompt = database.global_settings.system_prompt
+
+          reply = []
+          reply << if user_prompt
+                     "User system prompt: #{user_prompt}"
+                   else
+                     'User system prompt is not set.'
+                   end
+
+          reply << if global_prompt
+                     "Global system prompt: #{global_prompt}"
+                   else
+                     'Global system prompt is not set.'
+                   end
+
+          message.reply(reply.join("\n"))
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/actions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Ruboty AI Agent actions.
+    module Actions
+      autoload :AddAiCommand, 'ruboty/ai_agent/actions/add_ai_command'
+      autoload :AddAiMemory, 'ruboty/ai_agent/actions/add_ai_memory'
+      autoload :AddMcp, 'ruboty/ai_agent/actions/add_mcp'
+      autoload :Base, 'ruboty/ai_agent/actions/base'
+      autoload :Chat, 'ruboty/ai_agent/actions/chat'
+      autoload :ListAiCommands, 'ruboty/ai_agent/actions/list_ai_commands'
+      autoload :ListAiMemories, 'ruboty/ai_agent/actions/list_ai_memories'
+      autoload :ListMcp, 'ruboty/ai_agent/actions/list_mcp'
+      autoload :RemoveAiCommand, 'ruboty/ai_agent/actions/remove_ai_command'
+      autoload :RemoveAiMemory, 'ruboty/ai_agent/actions/remove_ai_memory'
+      autoload :RemoveMcp, 'ruboty/ai_agent/actions/remove_mcp'
+      autoload :SetSystemPrompt, 'ruboty/ai_agent/actions/set_system_prompt'
+      autoload :ShowSystemPrompt, 'ruboty/ai_agent/actions/show_system_prompt'
+    end
+  end
+end

data/lib/ruboty/ai_agent/agent.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Agent class to interact with LLM and manage conversations.
+    class Agent
+      attr_reader :llm #: LLM::OpenAI
+      attr_reader :messages #: Array[ChatMessage]
+      attr_reader :tools #: Array[Tool]
+
+      # @rbs llm: LLM::OpenAI
+      # @rbs messages: Array[ChatMessage]
+      # @rbs tools: Array[Tool]
+      def initialize(
+        llm:,
+        messages: [],
+        tools: []
+      )
+        @llm = llm
+        @messages = messages
+        @tools = tools
+      end
+
+      def complete(&)
+        loop do
+          response = llm.complete(
+            messages:,
+            tools:
+          )
+          on_response(response, &)
+          on_new_message(response.message, &)
+
+          if response.tool
+            on_tool_call(tool: response.tool, tool_arguments: response.tool_arguments, &)
+            messages << response.message
+
+            tool_response = response.call_tool || 'no return value'
+            tool_response_message = ChatMessage.from_llm_response(
+              tool: response.tool,
+              tool_call_id: response.tool_call_id,
+              tool_arguments: response.tool_arguments,
+              tool_response:
+            )
+            on_tool_response(tool_response:, message: tool_response_message, &)
+            messages << tool_response_message
+          else
+            messages << response.message
+
+            return response
+          end
+        end
+      end
+
+      def on_new_message(message, &callback)
+        callback&.call({ type: :new_message, message: })
+      end
+
+      def on_tool_call(tool:, tool_arguments:, &callback)
+        callback&.call({ type: :tool_call, tool:, tool_arguments: })
+      end
+
+      def on_tool_response(tool_response:, message:, &callback)
+        callback&.call({ type: :tool_response, tool_response:, message: })
+      end
+
+      def on_response(response, &callback)
+        callback&.call({ type: :response, response: })
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/cached_value.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Ruboty
+  module AiAgent
+    # Cache for MCP operations
+    # @rbs generic D < Object
+    class CachedValue
+      include Recordable
+
+      attr_reader :expires_at #: Time
+      attr_reader :data #: D
+
+      # @rbs data: D
+      # @rbs expires_at: Time
+      def initialize(data:, expires_at:)
+        @data = data
+        @expires_at = expires_at.is_a?(Time) ? expires_at.round : Time.parse(expires_at)
+      end
+
+      # @rbs return: Hash[Symbol, untyped]
+      def to_h
+        {
+          expires_at: expires_at.rfc2822,
+          data: data
+        }
+      end
+
+      # @rbs return: bool
+      def expired?
+        Time.now > expires_at
+      end
+
+      # @rbs return: bool
+      def valid?
+        !expired?
+      end
+
+      register_record_type :mcp_cache
+    end
+  end
+end

data/lib/ruboty/ai_agent/chat_message.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Save MCP configuration details.
+    class ChatMessage
+      include Recordable
+
+      register_record_type :chat_message
+
+      attr_reader :role #: Symbol
+      attr_reader :content #: String
+      attr_reader :tool_call_id #: String?
+      attr_reader :tool_name #: String?
+      attr_reader :tool_arguments #: Hash[Symbol | String, untyped]?
+      attr_reader :token_usage #: TokenUsage?
+
+      # @rbs role: Symbol
+      # @rbs content: String
+      # @rbs ?tool_call_id: String?
+      # @rbs ?tool_name: String?
+      # @rbs ?tool_arguments: Hash[Symbol | String, untyped]?
+      # @rbs ?token_usage: TokenUsage?
+      def initialize(role:, content:, tool_call_id: nil, tool_name: nil, tool_arguments: nil, token_usage: nil)
+        @role = role
+        @content = content
+        @tool_call_id = tool_call_id
+        @tool_name = tool_name
+        @tool_arguments = tool_arguments
+        @token_usage = token_usage
+      end
+
+      def to_h #: Hash[Symbol, untyped]
+        {
+          role:,
+          content:,
+          tool_call_id:,
+          tool_name:,
+          tool_arguments:,
+          token_usage:
+        }
+      end
+
+      def self.from_llm_response(
+        tool:,
+        tool_call_id:,
+        tool_arguments:,
+        tool_response:
+      ) #: ChatMessage
+        new(
+          role: :tool,
+          content: tool_response,
+          tool_name: tool.name,
+          tool_call_id:,
+          tool_arguments: tool_arguments
+        )
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/chat_thread.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Manage thread-specific data.
+    class ChatThread
+      attr_reader :database #: Ruboty::AiAgent::Database
+      attr_reader :id #: String
+
+      class << self
+        def find_or_create(database:, id:) #: ChatThread
+          new(database: database, id: id)
+        end
+      end
+
+      def initialize(database:, id:)
+        @database = database
+        @id = id
+      end
+
+      # @rbs %a{memorized}
+      def messages #: ChatThreadMessages
+        @messages ||= ChatThreadMessages.new(database: database, chat_thread_id: id)
+      end
+
+      def clear #: void
+        messages.clear
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/chat_thread_associations.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # A set of records for a specific thread.
+    # @rbs generic Record
+    class ChatThreadAssociations < RecordSet #[Record]
+      attr_reader :chat_thread_id #: String
+
+      def initialize(database:, chat_thread_id:)
+        super(database:)
+
+        @chat_thread_id = chat_thread_id
+      end
+
+      # @rbs!
+      #   def self.association_key: () -> Symbol
+      #   def self.association_key=: (Symbol) -> Symbol
+
+      # @rbs skip
+      class << self
+        attr_accessor :association_key
+      end
+
+      def association_key #: Symbol
+        self.class.association_key || raise(NotImplementedError, 'Subclasses must set the association_key method')
+      end
+
+      def namespace_keys
+        [:chat_threads, chat_thread_id, association_key]
+      end
+    end
+  end
+end

data/lib/ruboty/ai_agent/chat_thread_messages.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    # Manage messages for the chat thread.
+    class ChatThreadMessages < ChatThreadAssociations #[ChatMessage]
+      self.association_key = :messages
+
+      # @rbs message: ChatMessage
+      def add(message) #: void
+        store(message, key: (keys.last.to_s.to_i || -1) + 1)
+      end
+
+      alias << add
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Commands
+      # Base class for commands.
+      # @abstract
+      class Base
+        Matcher = Data.define(:pattern, :description, :name)
+
+        class << self
+          def matchers #: Array[Matcher]
+            @matchers ||= []
+          end
+
+          def on(pattern, name:, description:)
+            matchers << Matcher.new(pattern:, description:, name:)
+          end
+        end
+
+        # @rbs *args: untyped
+        # @rbs return: void
+        def call(*args)
+          raise NotImplementedError
+        end
+
+        # @rbs commandline: String
+        # @rbs return: boolish
+        def match?(commandline)
+          matchers.any? { |matcher| /\A\s*#{matcher.pattern}/.match?(commandline) }
+        end
+
+        def matchers #: Array[Matcher]
+          self.class.matchers
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Commands
+      # Clear histories of the chat thread.
+      class Clear < Base
+        on(%r{/clear}, name: 'clear', description: 'Clear the chat history.')
+
+        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
+          chat_thread.clear
+          message.reply('Cleared the chat history.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Commands
+      # Compact chat history by summarizing it
+      class Compact < Base
+        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?
+            message.reply('No chat history to compact.')
+            return
+          end
+
+          summary = generate_summary(messages)
+
+          chat_thread.clear
+          chat_thread.messages.add(
+            ChatMessage.new(
+              role: :system,
+              content: "Previous conversation summary: #{summary}"
+            )
+          )
+
+          message.reply('Chat history has been compacted with a summary.')
+        rescue StandardError => e
+          if ENV['DEBUG']
+            message.reply("エラーが発生しました: #{e.full_message}")
+          else
+            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
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ruboty
+  module AiAgent
+    module Commands
+      # Show token usage information for the latest AI response
+      class Usage < Base
+        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
+          latest_message = chat_thread.messages.all_values.find(&:token_usage)
+
+          token_usage = latest_message&.token_usage
+
+          if token_usage
+            usage_text = "Token usage: #{format_number(token_usage.prompt_tokens)} (prompt) + #{format_number(token_usage.completion_tokens)} (completion) = #{format_number(token_usage.total_tokens)} (total)"
+
+            limit = token_usage.token_limit
+            if limit
+              usage_percentage = token_usage.usage_percentage
+              usage_text += " / #{format_number(limit)} (#{usage_percentage}%)"
+            end
+
+            message.reply(usage_text)
+          else
+            message.reply('No token usage information found.')
+          end
+        end
+
+        private
+
+        # @rbs number: Integer
+        # @rbs return: String
+        def format_number(number)
+          number.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
+        end
+      end
+    end
+  end
+end