girb 0.1.0

data/lib/girb/tools/get_source.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../session_history"
+
+module Girb
+  module Tools
+    class GetSource < Base
+      MAX_SOURCE_LINES = 50
+
+      class << self
+        def description
+          "Get the source code of a method or class definition. Use 'Class#method' for instance methods, 'Class.method' for class methods."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              target: {
+                type: "string",
+                description: "Class or method to get source for (e.g., 'User', 'User#save', 'User.find')"
+              }
+            },
+            required: ["target"]
+          }
+        end
+      end
+
+      def execute(binding, target:)
+        if target.include?("#")
+          get_instance_method_source(binding, target)
+        elsif target.include?(".")
+          get_class_method_source(binding, target)
+        else
+          get_class_info(binding, target)
+        end
+      rescue NameError => e
+        { error: "Not found: #{e.message}" }
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def get_instance_method_source(binding, target)
+        class_name, method_name = target.split("#", 2)
+        klass = binding.eval(class_name)
+        method = klass.instance_method(method_name.to_sym)
+
+        extract_method_info(method, target)
+      end
+
+      def get_class_method_source(binding, target)
+        class_name, method_name = target.split(".", 2)
+        klass = binding.eval(class_name)
+        method = klass.method(method_name.to_sym)
+
+        extract_method_info(method, target)
+      end
+
+      def extract_method_info(method, target)
+        location = method.source_location
+        method_name = method.name.to_s
+
+        if location
+          file, line = location
+
+          # IRBで定義されたメソッドの場合、SessionHistoryから取得
+          if file == "(irb)" || file&.start_with?("(irb)")
+            session_method = SessionHistory.find_method(method_name)
+            if session_method
+              return {
+                target: target,
+                file: "(irb)",
+                line: "#{session_method.start_line}-#{session_method.end_line}",
+                source: session_method.code,
+                parameters: method.parameters.map { |type, name| "#{type}: #{name}" },
+                defined_in_session: true
+              }
+            end
+          end
+
+          source = read_source(file, line)
+          {
+            target: target,
+            file: file,
+            line: line,
+            source: source,
+            parameters: method.parameters.map { |type, name| "#{type}: #{name}" }
+          }
+        else
+          {
+            target: target,
+            error: "Source not available (native or C extension method)",
+            parameters: method.parameters.map { |type, name| "#{type}: #{name}" }
+          }
+        end
+      end
+
+      def get_class_info(binding, class_name)
+        klass = binding.eval(class_name)
+
+        {
+          name: klass.name,
+          type: klass.class.name,
+          ancestors: klass.ancestors.first(10).map(&:to_s),
+          instance_methods: klass.instance_methods(false).sort.first(30),
+          class_methods: (klass.methods - Class.methods).sort.first(30),
+          constants: klass.constants.first(20)
+        }
+      end
+
+      def read_source(file, start_line)
+        return nil unless File.exist?(file)
+
+        lines = File.readlines(file)
+        end_line = find_method_end(lines, start_line - 1)
+        lines[(start_line - 1)..end_line].join
+      rescue StandardError => e
+        "(Failed to read source: #{e.message})"
+      end
+
+      def find_method_end(lines, start_index)
+        # 簡易的なインデント解析でメソッド終端を探す
+        return [start_index + MAX_SOURCE_LINES, lines.length - 1].min if start_index >= lines.length
+
+        base_indent = lines[start_index][/^\s*/].length
+        end_keywords = %w[end]
+
+        (start_index + 1).upto([start_index + MAX_SOURCE_LINES, lines.length - 1].min) do |i|
+          line = lines[i]
+          next if line.strip.empty? || line.strip.start_with?("#")
+
+          current_indent = line[/^\s*/].length
+          if current_indent <= base_indent && end_keywords.any? { |kw| line.strip.start_with?(kw) }
+            return i
+          end
+        end
+
+        [start_index + MAX_SOURCE_LINES, lines.length - 1].min
+      end
+    end
+  end
+end

data/lib/girb/tools/inspect_object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class InspectObject < Base
+      class << self
+        def description
+          "Inspect a variable or expression in the current context. Returns detailed information about the object."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              expression: {
+                type: "string",
+                description: "The variable name or Ruby expression to inspect (e.g., 'user', 'user.errors', '@items.first')"
+              }
+            },
+            required: ["expression"]
+          }
+        end
+      end
+
+      def execute(binding, expression:)
+        result = binding.eval(expression)
+        {
+          expression: expression,
+          class: result.class.name,
+          value: safe_inspect(result),
+          instance_variables: extract_instance_variables(result),
+          methods_count: result.methods.count
+        }
+      rescue SyntaxError => e
+        { error: "Syntax error: #{e.message}" }
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def extract_instance_variables(obj)
+        obj.instance_variables.to_h do |var|
+          value = obj.instance_variable_get(var)
+          [var, safe_inspect(value, max_length: 200)]
+        end
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/girb/tools/list_methods.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class ListMethods < Base
+      class << self
+        def description
+          "List methods available on an object or class. Can filter by pattern."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              expression: {
+                type: "string",
+                description: "The variable name or expression to list methods for"
+              },
+              pattern: {
+                type: "string",
+                description: "Optional regex pattern to filter method names (e.g., 'valid', 'save')"
+              },
+              include_inherited: {
+                type: "boolean",
+                description: "Whether to include inherited methods (default: false)"
+              }
+            },
+            required: ["expression"]
+          }
+        end
+      end
+
+      def execute(binding, expression:, pattern: nil, include_inherited: false)
+        obj = binding.eval(expression)
+
+        methods = if obj.is_a?(Class) || obj.is_a?(Module)
+                    {
+                      instance_methods: obj.instance_methods(!include_inherited),
+                      class_methods: obj.methods(!include_inherited)
+                    }
+                  else
+                    {
+                      methods: obj.methods(!include_inherited)
+                    }
+                  end
+
+        # パターンでフィルタ
+        if pattern && !pattern.empty?
+          regex = Regexp.new(pattern, Regexp::IGNORECASE)
+          methods = methods.transform_values do |list|
+            list.select { |m| m.to_s.match?(regex) }
+          end
+        end
+
+        # ソートして返す
+        methods.transform_values(&:sort)
+      rescue RegexpError => e
+        { error: "Invalid pattern: #{e.message}" }
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+    end
+  end
+end

data/lib/girb/tools/rails_tools.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class RailsModelInfo < Base
+      class << self
+        def available?
+          defined?(ActiveRecord::Base)
+        end
+
+        def description
+          "Get Rails ActiveRecord model information including associations, validations, callbacks, and scopes."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              model_name: {
+                type: "string",
+                description: "The model class name (e.g., 'User', 'Order', 'Product')"
+              }
+            },
+            required: ["model_name"]
+          }
+        end
+      end
+
+      def execute(binding, model_name:)
+        klass = binding.eval(model_name)
+
+        unless klass < ActiveRecord::Base
+          return { error: "#{model_name} is not an ActiveRecord model" }
+        end
+
+        {
+          model: model_name,
+          table_name: klass.table_name,
+          primary_key: klass.primary_key,
+          columns: get_columns(klass),
+          associations: get_associations(klass),
+          validations: get_validations(klass),
+          callbacks: get_callbacks(klass),
+          scopes: get_scopes(klass)
+        }
+      rescue NameError => e
+        { error: "Model not found: #{e.message}" }
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def get_columns(klass)
+        klass.columns.map do |col|
+          {
+            name: col.name,
+            type: col.type,
+            null: col.null,
+            default: col.default
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      def get_associations(klass)
+        klass.reflect_on_all_associations.map do |assoc|
+          info = {
+            name: assoc.name,
+            type: assoc.macro,
+            class_name: assoc.class_name
+          }
+
+          # オプションがあれば追加
+          %i[dependent through source foreign_key].each do |opt|
+            value = assoc.options[opt]
+            info[opt] = value if value
+          end
+
+          info
+        end
+      rescue StandardError
+        []
+      end
+
+      def get_validations(klass)
+        klass.validators.map do |validator|
+          {
+            attributes: validator.attributes,
+            kind: validator.kind,
+            options: validator.options.reject { |k, _| %i[if unless].include?(k) }
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      def get_callbacks(klass)
+        callback_types = %i[
+          before_validation after_validation
+          before_save after_save around_save
+          before_create after_create around_create
+          before_update after_update around_update
+          before_destroy after_destroy around_destroy
+        ]
+
+        callback_types.to_h do |callback_type|
+          callbacks = begin
+            klass.send("_#{callback_type}_callbacks").map do |cb|
+              { filter: cb.filter.to_s, kind: cb.kind }
+            end
+          rescue StandardError
+            []
+          end
+          [callback_type, callbacks]
+        end.reject { |_, v| v.empty? }
+      end
+
+      def get_scopes(klass)
+        # Rails doesn't expose scope names directly, but we can check for scope methods
+        # that are defined on the class but not on ActiveRecord::Base
+        base_methods = ActiveRecord::Base.methods
+        scope_candidates = (klass.methods - base_methods).select do |method_name|
+          # スコープは通常、ActiveRecord::Relationを返す
+          begin
+            klass.respond_to?(method_name) &&
+              klass.method(method_name).arity <= 0
+          rescue StandardError
+            false
+          end
+        end
+        scope_candidates.sort.first(20)
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/girb/tools/read_file.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class ReadFile < Base
+      MAX_FILE_SIZE = 100_000  # 100KB
+      MAX_LINES = 500
+
+      class << self
+        def description
+          "Read source code from a file in the application. " \
+          "Can read models, controllers, views, configs, or any Ruby/text file. " \
+          "Optionally specify line range to read specific sections."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "File path (relative to app root or absolute). Examples: 'app/models/user.rb', 'config/routes.rb'"
+              },
+              start_line: {
+                type: "integer",
+                description: "Start line number (1-indexed, optional)"
+              },
+              end_line: {
+                type: "integer",
+                description: "End line number (1-indexed, optional)"
+              }
+            },
+            required: ["path"]
+          }
+        end
+      end
+
+      def execute(binding, path:, start_line: nil, end_line: nil)
+        full_path = resolve_path(path)
+
+        unless File.exist?(full_path)
+          return { error: "File not found: #{path}", searched_path: full_path }
+        end
+
+        unless File.readable?(full_path)
+          return { error: "File not readable: #{path}" }
+        end
+
+        if File.size(full_path) > MAX_FILE_SIZE
+          return { error: "File too large (max #{MAX_FILE_SIZE / 1000}KB): #{path}" }
+        end
+
+        read_file_content(full_path, path, start_line, end_line)
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def resolve_path(path)
+        return path if path.start_with?("/")
+
+        # Rails.root があればそこから
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          return File.join(Rails.root, path)
+        end
+
+        # Bundler.root があればそこから
+        if defined?(Bundler) && Bundler.respond_to?(:root) && Bundler.root
+          return File.join(Bundler.root, path)
+        end
+
+        # カレントディレクトリから
+        File.expand_path(path, Dir.pwd)
+      end
+
+      def read_file_content(full_path, original_path, start_line, end_line)
+        lines = File.readlines(full_path)
+        total_lines = lines.length
+
+        # 行範囲の指定がある場合
+        if start_line || end_line
+          start_idx = [(start_line || 1) - 1, 0].max
+          end_idx = [(end_line || total_lines) - 1, total_lines - 1].min
+          end_idx = [end_idx, start_idx + MAX_LINES - 1].min
+
+          selected_lines = lines[start_idx..end_idx]
+          content = selected_lines.map.with_index(start_idx + 1) { |line, num| "#{num}: #{line}" }.join
+
+          {
+            path: original_path,
+            full_path: full_path,
+            lines: "#{start_idx + 1}-#{end_idx + 1}",
+            total_lines: total_lines,
+            content: content
+          }
+        else
+          # 全体を読む（MAX_LINES制限あり）
+          if lines.length > MAX_LINES
+            content = lines.first(MAX_LINES).map.with_index(1) { |line, num| "#{num}: #{line}" }.join
+            {
+              path: original_path,
+              full_path: full_path,
+              lines: "1-#{MAX_LINES}",
+              total_lines: total_lines,
+              truncated: true,
+              content: content
+            }
+          else
+            content = lines.map.with_index(1) { |line, num| "#{num}: #{line}" }.join
+            {
+              path: original_path,
+              full_path: full_path,
+              total_lines: total_lines,
+              content: content
+            }
+          end
+        end
+      end
+    end
+  end
+end