girb 0.1.0

data/lib/girb/prompt_builder.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Girb
+  class PromptBuilder
+    SYSTEM_PROMPT = <<~PROMPT
+      You are girb, an AI assistant embedded in a Ruby developer's IRB session.
+
+      ## CRITICAL: Prompt Information Takes Highest Priority
+      Information in this system prompt and "User-Defined Instructions" section
+      takes precedence over tool results or user input.
+      When asked about environment or preconditions, check this prompt first.
+      Always verify if the information is already stated here before attempting programmatic detection.
+
+      ## Language
+      Respond in the same language the user is using. Detect the user's language from their question and match it.
+
+      ## Important: Understand the IRB Session Context
+      The user is interactively executing code in IRB and asking questions within that flow.
+      "Session History" contains the code the user has executed and past AI conversations in chronological order.
+      Always interpret questions in the context of this history.
+
+      For example, if the history shows:
+        1: a = 1
+        2: b = 2
+        3: [USER] What will z be if I continue with c = 3 and beyond?
+      The user is asking about the value of z when continuing the pattern a=1, b=2, c=3... (answer: z=26).
+
+      ## Your Role
+      - Strive to understand the user's true intent and background
+        - Don't just answer the question; understand what they're trying to achieve and what challenges they face
+      - Analyze session history to understand what the user is trying to do
+      - Utilize the current execution context (variables, object state, exceptions)
+      - Provide specific, practical answers to questions
+      - Use tools to execute and verify code as needed
+
+      ## You May Ask Clarifying Questions
+      When you have doubts, ask the user about preconditions or unclear points.
+      - When multiple interpretations are possible: Confirm which interpretation is correct
+      - When preconditions are unclear: Ask what they're aiming for, what environment they're assuming
+      - When information is insufficient: Prompt for the full error message or related code
+      Asking questions increases dialogue turns but reduces misunderstandings and enables more accurate answers.
+
+      ## Response Guidelines
+      - Keep responses concise and practical
+      - Read patterns and intentions; handle hypothetical questions
+      - Code examples should use variables and objects from the current IRB context and be directly executable by pasting into IRB
+
+      ## Debugging Support on Errors
+      When users encounter errors, actively support debugging.
+      - Don't just point out the cause; show debugging steps to resolve it
+      - Suggest ways to inspect related code (e.g., using the inspect_object tool)
+      - Guide them step-by-step toward writing more robust code
+
+      ## Available Tools
+      Use tools to inspect variables in detail, retrieve source code, and execute code.
+      Actively use the evaluate_code tool especially for verifying hypotheses and calculations.
+    PROMPT
+
+    def initialize(question, context)
+      @question = question
+      @context = context
+    end
+
+    # Legacy single prompt format (for backward compatibility)
+    def build
+      <<~PROMPT
+        #{system_prompt}
+
+        #{build_context_section}
+
+        ## Question
+        #{@question}
+      PROMPT
+    end
+
+    # System prompt (shared across conversation)
+    def system_prompt
+      custom = Girb.configuration&.custom_prompt
+      if custom && !custom.empty?
+        "#{SYSTEM_PROMPT}\n\n## User-Defined Instructions\n#{custom}"
+      else
+        SYSTEM_PROMPT
+      end
+    end
+
+    # User message (context + question)
+    def user_message
+      <<~MSG
+        ## Current IRB Context
+        #{build_context_section}
+
+        ## Question
+        #{@question}
+      MSG
+    end
+
+    private
+
+    def build_context_section
+      <<~CONTEXT
+        ### Session History (Previous IRB Inputs)
+        Below is the code the user has executed so far. The question is asked within this flow.
+        #{format_session_history}
+
+        ### Current Local Variables
+        #{format_locals}
+
+        ### Last Evaluation Result
+        #{@context[:last_value] || "(none)"}
+
+        ### Last Exception
+        #{format_exception}
+
+        ### Methods Defined in IRB
+        #{format_method_definitions}
+      CONTEXT
+    end
+
+    def format_source_location
+      loc = @context[:source_location]
+      return "(unknown)" unless loc
+
+      "File: #{loc[:file]}\nLine: #{loc[:line]}"
+    end
+
+    def format_locals
+      return "(none)" if @context[:local_variables].nil? || @context[:local_variables].empty?
+
+      @context[:local_variables].map do |name, value|
+        "- #{name}: #{value}"
+      end.join("\n")
+    end
+
+    def format_self_info
+      info = @context[:self_info]
+      return "(unknown)" unless info
+
+      lines = ["Class: #{info[:class]}"]
+      lines << "inspect: #{info[:inspect]}"
+      if info[:methods]&.any?
+        lines << "Defined methods: #{info[:methods].join(', ')}"
+      end
+      lines.join("\n")
+    end
+
+    def format_exception
+      exc = @context[:last_exception]
+      return "(none)" unless exc
+
+      <<~EXC
+        Class: #{exc[:class]}
+        Message: #{exc[:message]}
+        Time: #{exc[:time]}
+        Backtrace:
+        #{exc[:backtrace]&.map { |l| "  #{l}" }&.join("\n")}
+      EXC
+    end
+
+    def format_session_history
+      history = @context[:session_history]
+      return "(none)" if history.nil? || history.empty?
+
+      history.join("\n")
+    end
+
+    def format_method_definitions
+      methods = @context[:method_definitions]
+      return "(none)" if methods.nil? || methods.empty?
+
+      methods.join("\n")
+    end
+  end
+end

data/lib/girb/providers/base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Girb
+  module Providers
+    # Base class for LLM providers
+    # Implement this class to add support for new LLM providers
+    #
+    # Example:
+    #   class MyProvider < Girb::Providers::Base
+    #     def chat(messages:, system_prompt:, tools:)
+    #       # Call your LLM API
+    #       # Return Response object
+    #     end
+    #   end
+    #
+    #   Girb.configure do |c|
+    #     c.provider = MyProvider.new(api_key: "...")
+    #   end
+    #
+    class Base
+      # Send a chat request to the LLM
+      #
+      # @param messages [Array<Hash>] Conversation history in normalized format
+      #   Each message has :role (:user, :assistant, :tool_call, :tool_result) and :content
+      # @param system_prompt [String] System prompt
+      # @param tools [Array<Hash>] Tool definitions in normalized format
+      # @return [Response] Response object with text and/or function_calls
+      def chat(messages:, system_prompt:, tools:)
+        raise NotImplementedError, "#{self.class}#chat must be implemented"
+      end
+
+      # Response object returned by chat method
+      class Response
+        attr_reader :text, :function_calls, :error, :raw_response
+
+        def initialize(text: nil, function_calls: nil, error: nil, raw_response: nil)
+          @text = text
+          @function_calls = function_calls || []
+          @error = error
+          @raw_response = raw_response
+        end
+
+        def function_call?
+          @function_calls.any?
+        end
+      end
+
+      # Normalized tool definition format
+      # Providers should convert this to their specific format
+      #
+      # Example:
+      #   {
+      #     name: "evaluate_code",
+      #     description: "Execute Ruby code",
+      #     parameters: {
+      #       type: "object",
+      #       properties: {
+      #         code: { type: "string", description: "Ruby code to execute" }
+      #       },
+      #       required: ["code"]
+      #     }
+      #   }
+    end
+  end
+end

data/lib/girb/session_history.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Girb
+  # IRBセッション中の全入力を行番号付きで管理し、
+  # メソッド定義を追跡するクラス
+  class SessionHistory
+    Entry = Struct.new(:line_no, :code, :method_definition, :is_ai_question, :ai_response, :ai_reasoning, keyword_init: true)
+    MethodDef = Struct.new(:name, :start_line, :end_line, :code, keyword_init: true)
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def reset!
+        @instance = new
+      end
+
+      # 委譲メソッド
+      def record(line_no, code, is_ai_question: false)
+        instance.record(line_no, code, is_ai_question: is_ai_question)
+      end
+
+      def entries
+        instance.entries
+      end
+
+      def method_definitions
+        instance.method_definitions
+      end
+
+      def find_by_line(line_no)
+        instance.find_by_line(line_no)
+      end
+
+      def find_by_line_range(start_line, end_line)
+        instance.find_by_line_range(start_line, end_line)
+      end
+
+      def find_method(name)
+        instance.find_method(name)
+      end
+
+      def all_with_line_numbers
+        instance.all_with_line_numbers
+      end
+
+      def method_index
+        instance.method_index
+      end
+
+      def record_ai_response(line_no, response, reasoning = nil)
+        instance.record_ai_response(line_no, response, reasoning)
+      end
+
+      def get_ai_detail(line_no)
+        instance.get_ai_detail(line_no)
+      end
+
+      def ai_conversations
+        instance.ai_conversations
+      end
+    end
+
+    attr_reader :entries, :method_definitions
+
+    def initialize
+      @entries = []
+      @method_definitions = []
+      @pending_method = nil
+    end
+
+    # IRBからの入力を記録
+    def record(line_no, code, is_ai_question: false)
+      code = code.to_s.chomp
+
+      entry = Entry.new(line_no: line_no, code: code, method_definition: nil, is_ai_question: is_ai_question)
+
+      # メソッド定義の開始を検出
+      if code.match?(/^\s*def\s+\w+/)
+        @pending_method = {
+          start_line: line_no,
+          code_lines: [code]
+        }
+      elsif @pending_method
+        @pending_method[:code_lines] << code
+
+        # メソッド定義の終了を検出（簡易的なend検出）
+        if code.strip == "end" || code.match?(/^\s*end\s*$/)
+          method_name = extract_method_name(@pending_method[:code_lines].first)
+          full_code = @pending_method[:code_lines].join("\n")
+
+          method_def = MethodDef.new(
+            name: method_name,
+            start_line: @pending_method[:start_line],
+            end_line: line_no,
+            code: full_code
+          )
+          @method_definitions << method_def
+          entry.method_definition = method_def
+          @pending_method = nil
+        end
+      end
+
+      @entries << entry
+    end
+
+    # 特定の行番号のエントリを取得
+    def find_by_line(line_no)
+      @entries.find { |e| e.line_no == line_no }
+    end
+
+    # 行範囲のエントリを取得
+    def find_by_line_range(start_line, end_line)
+      @entries.select { |e| e.line_no >= start_line && e.line_no <= end_line }
+    end
+
+    # メソッド名でメソッド定義を検索
+    def find_method(name)
+      name = name.to_s
+      @method_definitions.find { |m| m.name == name }
+    end
+
+    # 全履歴を行番号付きで取得
+    def all_with_line_numbers
+      @entries.map do |e|
+        if e.is_ai_question
+          # AI会話は質問と回答をまとめて表示
+          response_preview = if e.ai_response
+                               truncate(e.ai_response, 100)
+                             else
+                               "(回答待ち)"
+                             end
+          "#{e.line_no}: [USER] #{e.code} => [AI] #{response_preview}"
+        else
+          "#{e.line_no}: #{e.code}"
+        end
+      end
+    end
+
+    def truncate(str, max_length)
+      str.length > max_length ? str[0, max_length] + "..." : str
+    end
+
+    # メソッド定義のインデックス（メソッド名: 行範囲）
+    def method_index
+      @method_definitions.map do |m|
+        if m.start_line == m.end_line
+          "#{m.name}: #{m.start_line}行目"
+        else
+          "#{m.name}: #{m.start_line}-#{m.end_line}行目"
+        end
+      end
+    end
+
+    # AI質問への回答と思考の過程を記録
+    def record_ai_response(line_no, response, reasoning = nil)
+      entry = find_by_line(line_no)
+      return unless entry
+
+      entry.ai_response = response
+      entry.ai_reasoning = reasoning
+    end
+
+    # 特定の行のAI詳細情報を取得
+    def get_ai_detail(line_no)
+      entry = find_by_line(line_no)
+      return nil unless entry&.ai_response
+
+      {
+        line_no: entry.line_no,
+        question: entry.code,
+        response: entry.ai_response,
+        reasoning: entry.ai_reasoning
+      }
+    end
+
+    # AI会話の一覧（質問と回答のみ、思考の過程は含まない）
+    def ai_conversations
+      @entries.select { |e| e.is_ai_question && e.ai_response }.map do |e|
+        {
+          line_no: e.line_no,
+          question: e.code,
+          response: e.ai_response
+        }
+      end
+    end
+
+    private
+
+    def extract_method_name(def_line)
+      # "def foo" や "def foo(bar)" からメソッド名を抽出
+      match = def_line.match(/def\s+(\w+[?!=]?)/)
+      match ? match[1] : "unknown"
+    end
+  end
+end

data/lib/girb/tools/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Girb
+  module Tools
+    class Base
+      class << self
+        def tool_name
+          name.split("::").last.gsub(/([A-Z])/) { "_#{$1.downcase}" }.sub(/^_/, "")
+        end
+
+        def description
+          raise NotImplementedError, "#{name} must implement .description"
+        end
+
+        def parameters
+          raise NotImplementedError, "#{name} must implement .parameters"
+        end
+
+        def to_gemini_tool
+          {
+            name: tool_name,
+            description: description,
+            parameters: parameters
+          }
+        end
+
+        def available?
+          true
+        end
+      end
+
+      def execute(binding, **params)
+        raise NotImplementedError, "#{self.class.name} must implement #execute"
+      end
+
+      protected
+
+      def safe_inspect(obj, max_length: 1000)
+        if defined?(ActiveRecord::Base) && obj.is_a?(ActiveRecord::Base)
+          return inspect_active_record(obj)
+        end
+
+        result = obj.inspect
+        result.length > max_length ? "#{result[0, max_length]}..." : result
+      rescue StandardError => e
+        "#<#{obj.class} (inspect failed: #{e.message})>"
+      end
+
+      def inspect_active_record(obj)
+        {
+          class: obj.class.name,
+          id: obj.try(:id),
+          attributes: obj.attributes,
+          new_record: obj.new_record?,
+          changed: obj.changed?,
+          errors: obj.errors.full_messages
+        }.to_s
+      end
+    end
+  end
+end

data/lib/girb/tools/evaluate_code.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class EvaluateCode < Base
+      class << self
+        def description
+          "Execute arbitrary Ruby code in the current context and return the result. " \
+          "Use this to call methods, create objects, test conditions, or perform any Ruby operation."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              code: {
+                type: "string",
+                description: "Ruby code to execute (e.g., 'user.valid?', 'Order.where(status: :pending).count', 'arr.map { |x| x * 2 }')"
+              }
+            },
+            required: ["code"]
+          }
+        end
+      end
+
+      def execute(binding, code:)
+        result = binding.eval(code)
+        {
+          code: code,
+          result: safe_inspect(result),
+          result_class: result.class.name,
+          success: true
+        }
+      rescue SyntaxError => e
+        { code: code, error: "Syntax error: #{e.message}", success: false }
+      rescue StandardError => e
+        { code: code, error: "#{e.class}: #{e.message}", backtrace: e.backtrace&.first(5), success: false }
+      end
+    end
+  end
+end

data/lib/girb/tools/find_file.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class FindFile < Base
+      MAX_RESULTS = 20
+
+      class << self
+        def description
+          "Find files in the application by name pattern. " \
+          "Useful for locating models, controllers, views, or any files. " \
+          "Supports glob patterns like '*.rb' or '**/*user*.rb'."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              pattern: {
+                type: "string",
+                description: "File name pattern (glob). Examples: 'user.rb', '**/user*.rb', 'app/models/*.rb'"
+              },
+              directory: {
+                type: "string",
+                description: "Directory to search in (optional, defaults to app root)"
+              }
+            },
+            required: ["pattern"]
+          }
+        end
+      end
+
+      def execute(binding, pattern:, directory: nil)
+        base_dir = resolve_base_directory(directory)
+
+        unless Dir.exist?(base_dir)
+          return { error: "Directory not found: #{base_dir}" }
+        end
+
+        # パターンにディレクトリが含まれていなければ再帰検索
+        search_pattern = if pattern.include?("/") || pattern.include?("**/")
+                           File.join(base_dir, pattern)
+                         else
+                           File.join(base_dir, "**", pattern)
+                         end
+
+        files = Dir.glob(search_pattern).reject { |f| File.directory?(f) }
+
+        # 結果を制限
+        truncated = files.length > MAX_RESULTS
+        files = files.first(MAX_RESULTS)
+
+        # 相対パスに変換
+        relative_files = files.map { |f| f.sub("#{base_dir}/", "") }
+
+        {
+          pattern: pattern,
+          base_directory: base_dir,
+          files: relative_files,
+          count: relative_files.length,
+          truncated: truncated
+        }
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def resolve_base_directory(directory)
+        if directory
+          return directory if directory.start_with?("/")
+
+          base = app_root
+          File.join(base, directory)
+        else
+          app_root
+        end
+      end
+
+      def app_root
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.to_s
+        elsif defined?(Bundler) && Bundler.respond_to?(:root) && Bundler.root
+          Bundler.root.to_s
+        else
+          Dir.pwd
+        end
+      end
+    end
+  end
+end