ruboty-ai_agent 0.1.0

data/script/generate-data-rbs.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'prism'
+require 'rbs'
+require 'pathname'
+require 'fileutils'
+
+# Process Ruby files to generate RBS definitions for Data classes
+class Processor
+  Source = Data.define(:file, :content, :prism_node)
+  RbsOutput = Data.define(:origin_source, :content)
+
+  def initialize(lib_path: 'lib', output_path: 'sig/generated-by-scripts')
+    @lib_path = Pathname(lib_path)
+    @output_path = Pathname(output_path)
+    @data_classes = []
+  end
+
+  def process
+    rbs_outputs = each_ruby_file.filter_map do |source|
+      DataClassRbsGenerator.new.process(source)
+    end
+
+    generate_rbs_files(rbs_outputs)
+  end
+
+  private
+
+  def each_ruby_file
+    puts "Scanning Ruby files in #{@lib_path}..."
+
+    @lib_path.glob('**/*.rb').map do |file|
+      puts "Processing #{file}..."
+      content = file.read
+
+      parsed = Prism.parse(content)
+
+      Source.new(file:, content:, prism_node: parsed.value)
+    end
+  end
+
+  def generate_rbs_files(rbs_outputs)
+    return if rbs_outputs.empty?
+
+    puts "\nGenerating RBS files..."
+    FileUtils.mkdir_p(@output_path)
+
+    content = []
+    content << '# Generated RBS definitions'
+    content << '# This file is automatically generated by script/generate-rbs.rb'
+    content << ''
+    content.concat(rbs_outputs.map(&:content))
+
+    rbs_content = content.join("\n")
+    output_file = @output_path / 'data_classes.rbs'
+
+    File.write(output_file, rbs_content)
+    puts "Generated #{output_file}"
+  end
+end
+
+# Generate RBS definitions for Data classes found in Ruby files
+class DataClassRbsGenerator
+  DataClass = Data.define(:name, :namespace, :full_name, :attributes, :file)
+
+  # @rbs source: Processor::Source
+  # @rbs return: Processor::RbsOutput?
+  def process(source)
+    visitor = Visitor.new(source)
+    source.prism_node.accept(visitor)
+
+    data_classes = visitor.data_classes
+
+    # Remove duplicates by keeping only unique full_name entries
+    data_classes.uniq!(&:full_name)
+
+    return if data_classes.empty?
+
+    puts "Found #{data_classes.size} Data classes:"
+    data_classes.each do |data_class|
+      puts "  - #{data_class.full_name} with attributes: #{data_class.attributes.join(', ')}"
+    end
+
+    rbs_content = RbsPrinter.new(data_classes:).generate_rbs_content
+    Processor::RbsOutput.new(origin_source: source, content: rbs_content)
+  end
+
+  # Visitor to traverse the Prism AST and extract Data class information
+  class Visitor < Prism::Visitor
+    attr_reader :source #: Source
+    attr_reader :data_classes #: Array[DataClass]
+    attr_reader :namespace #: Array[Symbol]
+
+    def initialize(source) # rubocop:disable Lint/MissingSuper --- Prism::Visitor has no initialize method
+      @source = source
+      @data_classes = []
+      @namespace = []
+    end
+
+    def visit_class_node(node)
+      class_name = extract_constant_name(node.constant_path)
+
+      if data_class?(node)
+        attributes = extract_data_attributes(node)
+        if attributes
+          @data_classes << DataClass.new(
+            name: class_name,
+            namespace: namespace.dup,
+            full_name: [*namespace, class_name].join('::'),
+            attributes: attributes,
+            file: source.file
+          )
+        end
+      end
+
+      in_namespace(class_name) { super }
+    end
+
+    def visit_module_node(node)
+      module_name = extract_constant_name(node.constant_path)
+
+      in_namespace(module_name) do
+        super
+      end
+    end
+
+    def extract_constant_name(constant_path)
+      case constant_path
+      when Prism::ConstantReadNode
+        constant_path.name.to_s
+      when Prism::ConstantPathNode
+        constant_path.name.to_s
+      end
+    end
+
+    def data_class?(node)
+      return false unless node.superclass
+
+      case node.superclass
+      when Prism::CallNode
+        if node.superclass.receiver.is_a?(Prism::ConstantReadNode) &&
+           node.superclass.receiver.name == :Data &&
+           node.superclass.name == :define
+          return true
+        end
+      end
+
+      false
+    end
+
+    def extract_data_attributes(node)
+      return nil unless node.superclass.is_a?(Prism::CallNode)
+      return nil unless node.superclass.name == :define
+
+      arguments = node.superclass.arguments
+      return nil unless arguments
+
+      attributes = []
+      arguments.arguments.each do |arg|
+        case arg
+        when Prism::SymbolNode
+          attributes << arg.value.to_s
+        end
+      end
+
+      attributes.empty? ? nil : attributes
+    end
+
+    # @rbs new_namespace: String?
+    def in_namespace(new_namespace)
+      if new_namespace
+        @namespace << new_namespace
+        yield.tap { @namespace.pop }
+      else
+        yield
+      end
+    end
+  end
+
+  # Print RBS definitions
+  class RbsPrinter
+    attr_reader :data_classes
+
+    def initialize(data_classes:)
+      @data_classes = data_classes
+    end
+
+    def generate_rbs_content #: String
+      content = []
+
+      @data_classes.group_by(&:namespace).each do |namespace, classes|
+        if namespace.empty?
+          classes.each do |data_class|
+            content << generate_class_rbs(data_class, 0)
+            content << ''
+          end
+        else
+          content.concat(generate_namespaced_classes_rbs(namespace, classes, 0))
+        end
+      end
+
+      content.join("\n")
+    end
+
+    def generate_namespaced_classes_rbs(namespace, classes, indent_level)
+      content = []
+
+      namespace.each_with_index do |ns, index|
+        content << indent("module #{ns}", level: indent_level + index)
+      end
+
+      classes.each do |data_class|
+        content << generate_class_rbs(data_class, indent_level + namespace.size)
+        content << ''
+      end
+
+      namespace.reverse.each_with_index do |_ns, index|
+        content << indent('end', level: indent_level + namespace.size - index - 1)
+      end
+
+      content << ''
+      content
+    end
+
+    def generate_class_rbs(data_class, indent_level)
+      content = []
+      content << indent("class #{data_class.name} < Data", level: indent_level)
+
+      data_class.attributes.each do |attr|
+        content << indent("def #{attr}: () -> untyped", level: indent_level + 1)
+      end
+
+      content << indent("def initialize: (#{generate_initialize_signature(data_class.attributes)}) -> void", level: indent_level + 1)
+      content << indent('end', level: indent_level)
+
+      content.join("\n")
+    end
+
+    def generate_initialize_signature(attributes)
+      attributes.map { |attr| "#{attr}: untyped" }.join(', ')
+    end
+
+    def indent(string, level:)
+      '  ' * level + string
+    end
+  end
+end
+
+Processor.new.process if __FILE__ == $PROGRAM_NAME

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

@@ -0,0 +1,292 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Generate RBS instance variable definitions for memorized methods
+#
+# This script detects methods with @rbs %a{memorized} annotation and generates
+# corresponding instance variable RBS definitions.
+#
+# Example Ruby code that this script detects:
+#
+#   class User
+#     # @rbs %a{memorized}
+#     def profile #: Profile
+#       @profile ||= Profile.find(user_id: id)
+#     end
+#
+#     # @rbs %a{memorized}
+#     def settings #: Settings
+#       @settings ||= Settings.new(user: self)
+#     end
+#   end
+#
+# This will generate:
+#
+#   class User
+#     @profile: Profile
+#     @settings: Settings
+#   end
+#
+# The script:
+# 1. Looks for methods with @rbs %a{memorized} annotation
+# 2. Extracts instance variable names from @ivar ||= patterns
+# 3. Gets return type from method signature comment (#: Type)
+# 4. Generates RBS definitions for the instance variables
+
+require 'prism'
+require 'pathname'
+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)
+
+  def initialize(lib_path: 'lib', output_path: 'sig/generated-by-scripts', namespace_filter: nil)
+    @lib_path = Pathname(lib_path)
+    @output_path = Pathname(output_path)
+    @namespace_filter = namespace_filter
+  end
+
+  def process
+    memorized_methods = find_memorized_methods
+
+    if memorized_methods.empty?
+      puts 'No memorized methods found'
+      return
+    end
+
+    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}"
+    end
+
+    generate_rbs_files(memorized_methods)
+  end
+
+  private
+
+  def find_memorized_methods
+    methods = []
+
+    @lib_path.glob('**/*.rb').each do |file|
+      content = file.read
+      parsed = Prism.parse(content)
+
+      source = Source.new(file: file, content: content, prism_node: parsed.value)
+      visitor = MemorizedMethodVisitor.new(source, namespace_filter: @namespace_filter)
+      parsed.value.accept(visitor)
+
+      methods.concat(visitor.memorized_methods)
+    end
+
+    methods
+  end
+
+  def generate_rbs_files(memorized_methods)
+    puts "\nGenerating RBS files..."
+    FileUtils.mkdir_p(@output_path)
+
+    content = []
+    content << '# Generated RBS definitions for memorized instance variables'
+    content << '# This file is automatically generated by script/generate-memorized-ivar-rbs.rb'
+    content << ''
+
+    # Group by class name
+    grouped = memorized_methods.group_by(&:class_name)
+
+    grouped.each do |class_name, methods|
+      parts = class_name.split('::')
+      indent_level = 0
+
+      # Open namespaces
+      parts[0...-1].each do |part|
+        content << ('  ' * indent_level) + "module #{part}"
+        indent_level += 1
+      end
+
+      # Class declaration with instance variables
+      content << ('  ' * indent_level) + "class #{parts.last}"
+
+      methods.each do |method|
+        content << ('  ' * (indent_level + 1)) + "@#{method.ivar_name}: #{method.return_type}"
+      end
+
+      content << "#{'  ' * indent_level}end"
+
+      # Close namespaces
+      (parts.size - 1).times do
+        indent_level -= 1
+        content << "#{'  ' * indent_level}end"
+      end
+
+      content << ''
+    end
+
+    output_file = @output_path / 'memorized_ivars.rbs'
+    File.write(output_file, content.join("\n"))
+    puts "Generated #{output_file}"
+  end
+
+  # Visitor to find memorized methods in Ruby source
+  class MemorizedMethodVisitor < Prism::Visitor
+    attr_reader :source, :memorized_methods, :namespace_filter, :namespace
+
+    def initialize(source, namespace_filter: nil)
+      @source = source
+      @namespace_filter = namespace_filter
+      @memorized_methods = []
+      @namespace = []
+      @current_class = nil
+      super()
+    end
+
+    def visit_class_node(node)
+      class_name = extract_constant_name(node.constant_path)
+
+      in_namespace(class_name, is_class: true) do
+        super
+      end
+    end
+
+    def visit_module_node(node)
+      module_name = extract_constant_name(node.constant_path)
+
+      in_namespace(module_name, is_class: false) do
+        super
+      end
+    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 for memorized annotation
+      if memorized_annotated?(node)
+        method_name = node.name.to_s
+
+        # Extract instance variable name and return type
+        ivar_info = extract_ivar_and_type(node)
+
+        if ivar_info
+          @memorized_methods << MemorizedIvarRbsGenerator::MemorizedMethod.new(
+            class_name: @current_class,
+            method_name: method_name,
+            ivar_name: ivar_info[:ivar_name],
+            return_type: ivar_info[:return_type],
+            file: source.file
+          )
+        end
+      end
+
+      super
+    end
+
+    private
+
+    def extract_constant_name(constant_path)
+      case constant_path
+      when Prism::ConstantReadNode
+        constant_path.name.to_s
+      when Prism::ConstantPathNode
+        constant_path.name.to_s
+      end
+    end
+
+    def in_namespace(name, is_class: false)
+      if name
+        @namespace << name
+        old_class = @current_class
+        @current_class = @namespace.join('::') if is_class
+        yield
+        @current_class = old_class
+        @namespace.pop
+      else
+        yield
+      end
+    end
+
+    def memorized_annotated?(node)
+      return false unless node.location
+
+      lines = source.content.lines
+      method_line = node.location.start_line
+
+      # Check the line before the method definition
+      return false if method_line <= 1
+
+      comment_line = lines[method_line - 2] # -2 because line numbers are 1-based
+      return false unless comment_line
+
+      comment_line.include?('@rbs %a{memorized}') || comment_line.include?('@rbs %a{ memorized }')
+    end
+
+    def extract_ivar_and_type(node)
+      return nil unless node.body
+
+      # Find instance variable assignments in the method body
+      ivar_name = find_ivar_assignment(node.body)
+      return nil unless ivar_name
+
+      # Extract return type from the method signature comment if present
+      return_type = extract_return_type_from_comment(node)
+
+      {
+        ivar_name: ivar_name,
+        return_type: return_type || 'untyped'
+      }
+    end
+
+    def find_ivar_assignment(node, depth = 0)
+      case node
+      when Prism::StatementsNode
+        # Look through all statements
+        node.body.each do |statement|
+          result = find_ivar_assignment(statement, depth + 1)
+          return result if result
+        end
+        nil
+      when Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode
+        # This handles @ivar ||= ...
+        node.name.to_s.delete('@')
+      when Prism::InstanceVariableWriteNode
+        # This handles @ivar = ...
+        node.name.to_s.delete('@')
+      else
+        # Recursively search in child nodes
+        if node.respond_to?(:compact_child_nodes)
+          node.compact_child_nodes.each do |child|
+            result = find_ivar_assignment(child, depth + 1)
+            return result if result
+          end
+        end
+        nil
+      end
+    end
+
+    def extract_return_type_from_comment(node)
+      lines = source.content.lines
+      method_line = node.location.start_line
+
+      # Look for the method signature in the same line as def
+      # Pattern: #: ReturnType or #: (...) -> ReturnType
+      line = lines[method_line - 1] # -1 because line numbers are 1-based
+      return nil unless line
+
+      # Match patterns like "#: ChatThreadMessages" or "#: () -> ChatThreadMessages"
+      if (match = line.match(/#:\s*(?:\([^)]*\)\s*->\s*)?(.+)/))
+        return match[1].strip
+      end
+
+      nil
+    end
+  end
+end
+
+# Run if executed directly
+if __FILE__ == $PROGRAM_NAME
+  generator = MemorizedIvarRbsGenerator.new(namespace_filter: 'Ruboty')
+  generator.process
+end

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

@@ -0,0 +1,16 @@
+# Generated from lib/ruboty/ai_agent/actions/add_ai_command.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # AddAiCommand action for Ruboty::AiAgent
+      class AddAiCommand < Base
+        def call: () -> untyped
+
+        def name_param: () -> String
+
+        def prompt_param: () -> String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# Generated from lib/ruboty/ai_agent/actions/add_ai_memory.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # AddAiMemory action for Ruboty::AiAgent
+      class AddAiMemory < Base
+        def call: () -> untyped
+
+        def prompt_param: () -> String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Generated from lib/ruboty/ai_agent/actions/add_mcp.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # AddMcp action for Ruboty::AiAgent
+      class AddMcp < Base
+        def call: () -> untyped
+
+        def name_param: () -> String
+
+        def config_param: () -> String
+
+        private
+
+        type config = { transport: :http | :sse, headers: Hash[String, String], args: Array[String] }
+
+        def parse_config: () -> config
+
+        # @rbs str: String
+        # @rbs return: String
+        def undump_string: (String str) -> String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# Generated from lib/ruboty/ai_agent/actions/base.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # Base class for actions.
+      # @abstract
+      class Base
+        attr_reader message: Ruboty::Message
+
+        # @rbs message: Ruboty::Message
+        # @rbs return: void
+        def self.call: (Ruboty::Message message) -> void
+
+        # @rbs return: void
+        def call: () -> void
+
+        def initialize: (untyped message) -> untyped
+
+        # @rbs %a{memorized}
+        %a{memorized}
+        def database: () -> Ruboty::AiAgent::Database
+
+        # @rbs %a{memorized}
+        %a{memorized}
+        def user: () -> Ruboty::AiAgent::User
+
+        # @rbs %a{memorized}
+        %a{memorized}
+        def chat_thread: () -> Ruboty::AiAgent::ChatThread
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# Generated from lib/ruboty/ai_agent/actions/chat.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # Chat action for Ruboty::AiAgent
+      class Chat < Base
+        CONVERSATION_KEY: ::Symbol
+
+        # @rbs override
+        def call: ...
+
+        def body_param: () -> String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# Generated from lib/ruboty/ai_agent/actions/list_ai_commands.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ListAiCommands action for Ruboty::AiAgent
+      class ListAiCommands < Base
+        # @rbs override
+        def call: ...
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# Generated from lib/ruboty/ai_agent/actions/list_ai_memories.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ListAiMemories action for Ruboty::AiAgent
+      class ListAiMemories < Base
+        def call: () -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# Generated from lib/ruboty/ai_agent/actions/list_mcp.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # ListMcp action for Ruboty::AiAgent
+      class ListMcp < Base
+        def call: () -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# Generated from lib/ruboty/ai_agent/actions/remove_ai_command.rb with RBS::Inline
+
+module Ruboty
+  module AiAgent
+    module Actions
+      # RemoveAiCommand action for Ruboty::AiAgent
+      class RemoveAiCommand < Base
+        def call: () -> untyped
+
+        def name_param: () -> String
+      end
+    end
+  end
+end