girb 0.1.0

data/lib/girb/ai_client.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "conversation_history"
+require_relative "providers/base"
+
+module Girb
+  class AiClient
+    MAX_TOOL_ITERATIONS = 10
+
+    def initialize
+      @provider = Girb.configuration.provider!
+    end
+
+    def ask(question, context, binding: nil, line_no: nil)
+      @current_binding = binding
+      @current_line_no = line_no
+      @reasoning_log = []
+
+      prompt_builder = PromptBuilder.new(question, context)
+      @system_prompt = prompt_builder.system_prompt
+      user_message = prompt_builder.user_message
+
+      ConversationHistory.add_user_message(user_message)
+
+      tools = build_tools
+      process_with_tools(tools)
+    end
+
+    private
+
+    def build_tools
+      Tools.available_tools.map do |tool_class|
+        {
+          name: tool_class.tool_name,
+          description: tool_class.description,
+          parameters: tool_class.parameters
+        }
+      end
+    end
+
+    def process_with_tools(tools)
+      iterations = 0
+      accumulated_text = []
+
+      loop do
+        iterations += 1
+        if iterations > MAX_TOOL_ITERATIONS
+          puts "\n[girb] Tool iteration limit reached"
+          break
+        end
+
+        messages = ConversationHistory.to_normalized
+        response = @provider.chat(
+          messages: messages,
+          system_prompt: @system_prompt,
+          tools: tools
+        )
+
+        if Girb.configuration.debug
+          puts "[girb] function_calls: #{response.function_calls.inspect}"
+          puts "[girb] text: #{response.text&.slice(0, 100).inspect}"
+          puts "[girb] error: #{response.error.inspect}" if response.error
+        end
+
+        unless response
+          puts "[girb] Error: No response from API"
+          break
+        end
+
+        if response.error && !response.function_call?
+          puts "[girb] API Error: #{response.error}"
+          break
+        end
+
+        if response.function_call?
+          # Accumulate text that comes with function calls
+          if response.text && !response.text.empty?
+            accumulated_text << response.text
+          end
+
+          function_call = response.function_calls.first
+          tool_name = function_call[:name]
+          tool_args = function_call[:args] || {}
+
+          if Girb.configuration.debug
+            puts "[girb] Tool: #{tool_name}(#{tool_args.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')})"
+          end
+
+          result = execute_tool(tool_name, tool_args)
+
+          @reasoning_log << {
+            tool: tool_name,
+            args: tool_args,
+            result: result
+          }
+
+          # Record tool call and result in conversation history
+          ConversationHistory.add_tool_call(tool_name, tool_args, result)
+
+          if Girb.configuration.debug && result.is_a?(Hash) && result[:error]
+            puts "[girb] Tool error: #{result[:error]}"
+          end
+        else
+          # Text response
+          if response.text && !response.text.empty?
+            accumulated_text << response.text
+          end
+
+          if accumulated_text.any?
+            full_text = accumulated_text.join("\n")
+            puts full_text
+            ConversationHistory.add_assistant_message(full_text)
+            record_ai_response(full_text)
+          elsif Girb.configuration.debug
+            puts "[girb] Warning: Empty or unexpected response"
+          end
+          break
+        end
+      end
+    end
+
+    def execute_tool(tool_name, args)
+      tool_class = Tools.find_tool(tool_name)
+
+      unless tool_class
+        return { error: "Unknown tool: #{tool_name}" }
+      end
+
+      tool = tool_class.new
+      symbolized_args = args.transform_keys(&:to_sym)
+
+      if @current_binding
+        tool.execute(@current_binding, **symbolized_args)
+      else
+        { error: "No binding available for tool execution" }
+      end
+    rescue StandardError => e
+      { error: "Tool execution failed: #{e.class} - #{e.message}" }
+    end
+
+    def record_ai_response(response)
+      return unless @current_line_no
+
+      reasoning = @reasoning_log.empty? ? nil : format_reasoning
+      SessionHistory.record_ai_response(@current_line_no, response, reasoning)
+    end
+
+    def format_reasoning
+      @reasoning_log.map do |log|
+        args_str = log[:args].map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        result_str = log[:result].inspect
+        result_str = result_str[0, 500] + "..." if result_str.length > 500
+        "Tool: #{log[:tool]}(#{args_str})\nResult: #{result_str}"
+      end.join("\n\n")
+    end
+  end
+end

data/lib/girb/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Girb
+  class Configuration
+    attr_accessor :provider, :debug, :custom_prompt
+
+    def initialize
+      @provider = nil
+      @debug = ENV["GIRB_DEBUG"] == "1"
+      @custom_prompt = nil
+    end
+
+    # Get the configured provider, or raise an error if not configured
+    def provider!
+      return @provider if @provider
+
+      raise ConfigurationError, <<~MSG
+        No LLM provider configured.
+
+        Install a provider gem and set GIRB_PROVIDER environment variable:
+
+          gem install girb-ruby_llm
+          export GIRB_PROVIDER=girb-ruby_llm
+
+        Or implement your own provider:
+
+          class MyProvider < Girb::Providers::Base
+            def chat(messages:, system_prompt:, tools:)
+              # Your implementation
+            end
+          end
+
+          Girb.configure do |c|
+            c.provider = MyProvider.new
+          end
+      MSG
+    end
+  end
+end

data/lib/girb/context_builder.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "session_history"
+
+module Girb
+  class ContextBuilder
+    MAX_INSPECT_LENGTH = 500
+
+    def initialize(binding, irb_context = nil)
+      @binding = binding
+      @irb_context = irb_context
+    end
+
+    def build
+      {
+        source_location: capture_source_location,
+        local_variables: capture_locals,
+        instance_variables: capture_instance_variables,
+        class_variables: capture_class_variables,
+        global_variables: capture_global_variables,
+        self_info: capture_self,
+        last_value: capture_last_value,
+        last_exception: ExceptionCapture.last_exception,
+        session_history: session_history_with_line_numbers,
+        method_definitions: session_method_definitions
+      }
+    end
+
+    private
+
+    def capture_source_location
+      loc = @binding.source_location
+      return nil unless loc
+
+      file, line = loc
+      {
+        file: file,
+        line: line
+      }
+    rescue StandardError
+      nil
+    end
+
+    def capture_locals
+      @binding.local_variables.to_h do |var|
+        value = @binding.local_variable_get(var)
+        [var, safe_inspect(value)]
+      end
+    end
+
+    def capture_instance_variables
+      obj = @binding.receiver
+      obj.instance_variables.to_h do |var|
+        value = obj.instance_variable_get(var)
+        [var, safe_inspect(value)]
+      end
+    rescue StandardError
+      {}
+    end
+
+    def capture_class_variables
+      obj = @binding.receiver
+      klass = obj.is_a?(Class) ? obj : obj.class
+      klass.class_variables.to_h do |var|
+        value = klass.class_variable_get(var)
+        [var, safe_inspect(value)]
+      end
+    rescue StandardError
+      {}
+    end
+
+    def capture_global_variables
+      # よく使われる重要なグローバル変数のみ収集（全部は多すぎる）
+      important_globals = %i[$! $@ $~ $& $` $' $+ $1 $2 $3 $stdin $stdout $stderr $DEBUG $VERBOSE $LOAD_PATH $LOADED_FEATURES]
+      important_globals.each_with_object({}) do |var, hash|
+        next unless global_variables.include?(var)
+
+        value = eval(var.to_s) # rubocop:disable Security/Eval
+        hash[var] = safe_inspect(value) unless value.nil?
+      rescue StandardError
+        next
+      end
+    end
+
+    def capture_self
+      obj = @binding.receiver
+      {
+        class: obj.class.name,
+        inspect: safe_inspect(obj),
+        methods: obj.methods(false).first(20)
+      }
+    end
+
+    def capture_last_value
+      return nil unless @irb_context
+
+      safe_inspect(@irb_context.last_value)
+    end
+
+    def safe_inspect(obj, max_length: MAX_INSPECT_LENGTH)
+      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
+      }
+    end
+
+    def session_history_with_line_numbers
+      SessionHistory.all_with_line_numbers
+    rescue StandardError
+      []
+    end
+
+    def session_method_definitions
+      SessionHistory.method_index
+    rescue StandardError
+      []
+    end
+  end
+end

data/lib/girb/conversation_history.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Girb
+  # AI会話履歴をchat API形式で管理するクラス
+  class ConversationHistory
+    Message = Struct.new(:role, :content, :tool_calls, :tool_results, keyword_init: true)
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def reset!
+        @instance = new
+      end
+
+      def add_user_message(content)
+        instance.add_user_message(content)
+      end
+
+      def add_assistant_message(content)
+        instance.add_assistant_message(content)
+      end
+
+      def add_tool_call(tool_name, args, result)
+        instance.add_tool_call(tool_name, args, result)
+      end
+
+      def to_contents
+        instance.to_contents
+      end
+
+      def messages
+        instance.messages
+      end
+
+      def clear!
+        instance.clear!
+      end
+
+      def summary
+        instance.summary
+      end
+
+      def to_normalized
+        instance.to_normalized
+      end
+    end
+
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+      @pending_tool_calls = []
+    end
+
+    def add_user_message(content)
+      @messages << Message.new(role: "user", content: content)
+    end
+
+    def add_assistant_message(content)
+      # ツール呼び出しがあった場合は、それも含める
+      if @pending_tool_calls.any?
+        @messages << Message.new(
+          role: "model",
+          content: content,
+          tool_calls: @pending_tool_calls.dup
+        )
+        @pending_tool_calls.clear
+      else
+        @messages << Message.new(role: "model", content: content)
+      end
+    end
+
+    def add_tool_call(tool_name, args, result)
+      @pending_tool_calls << {
+        name: tool_name,
+        args: args,
+        result: result
+      }
+    end
+
+    def clear!
+      @messages.clear
+      @pending_tool_calls.clear
+    end
+
+    # Gemini API の contents 形式に変換（後方互換性のため残す）
+    def to_contents
+      @messages.map do |msg|
+        {
+          role: msg.role,
+          parts: [{ text: msg.content }]
+        }
+      end
+    end
+
+    # Provider-agnostic normalized format
+    def to_normalized
+      result = []
+
+      @messages.each do |msg|
+        role = msg.role == "model" ? :assistant : :user
+        result << { role: role, content: msg.content }
+
+        # Add tool calls and results if present
+        msg.tool_calls&.each do |tc|
+          result << { role: :tool_call, name: tc[:name], args: tc[:args] }
+          result << { role: :tool_result, name: tc[:name], result: tc[:result] }
+        end
+      end
+
+      # Add pending tool calls
+      @pending_tool_calls.each do |tc|
+        result << { role: :tool_call, name: tc[:name], args: tc[:args] }
+        result << { role: :tool_result, name: tc[:name], result: tc[:result] }
+      end
+
+      result
+    end
+
+    # 会話履歴のサマリー（デバッグ用）
+    def summary
+      @messages.map do |msg|
+        role_label = msg.role == "user" ? "USER" : "AI"
+        content_preview = msg.content.to_s[0, 50]
+        content_preview += "..." if msg.content.to_s.length > 50
+        "#{role_label}: #{content_preview}"
+      end
+    end
+  end
+end

data/lib/girb/exception_capture.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Girb
+  module ExceptionCapture
+    @last_exception = nil
+    @last_exception_binding = nil
+    @trace_point = nil
+
+    class << self
+      attr_reader :last_exception, :last_exception_binding
+
+      def capture(exception, binding = nil)
+        @last_exception = {
+          class: exception.class.name,
+          message: exception.message,
+          backtrace: exception.backtrace&.first(10),
+          time: Time.now
+        }
+        @last_exception_binding = binding
+      end
+
+      def clear
+        @last_exception = nil
+        @last_exception_binding = nil
+      end
+
+      def install
+        return if @trace_point
+
+        @trace_point = TracePoint.new(:raise) do |tp|
+          # IRB内部・Ruby内部の例外は除外
+          next if tp.path&.include?("irb")
+          next if tp.path&.include?("error_highlight")
+          next if tp.path&.include?("reline")
+          next if tp.path&.include?("readline")
+          next if tp.path&.include?("rdoc")
+          next if tp.path&.include?("/ri/")
+          next if tp.raised_exception.is_a?(SystemExit)
+          next if tp.raised_exception.is_a?(Interrupt)
+          # ErrorHighlight内部の例外を除外
+          next if tp.raised_exception.class.name&.start_with?("ErrorHighlight::")
+
+          capture(tp.raised_exception, tp.binding)
+        end
+        @trace_point.enable
+      end
+
+      def uninstall
+        @trace_point&.disable
+        @trace_point = nil
+      end
+    end
+  end
+end

data/lib/girb/irb_integration.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "irb"
+require "irb/command"
+require_relative "exception_capture"
+require_relative "context_builder"
+require_relative "session_history"
+require_relative "ai_client"
+
+module Girb
+  # AI送信フラグ（スレッドローカル）
+  def self.ai_send_pending?
+    Thread.current[:girb_ai_send_pending]
+  end
+
+  def self.ai_send_pending=(value)
+    Thread.current[:girb_ai_send_pending] = value
+  end
+
+  module IrbIntegration
+    def self.setup
+      # コマンドを登録
+      require_relative "../irb/command/qq"
+
+      # 例外キャプチャのインストール
+      ExceptionCapture.install
+
+      # Ctrl+Space でAI送信するフックをインストール
+      install_eval_hook
+
+      # Ctrl+Space キーバインドをインストール
+      install_ai_keybinding
+    end
+
+    def self.install_eval_hook
+      IRB::Context.prepend(EvalHook)
+    end
+
+    def self.install_ai_keybinding
+      return unless defined?(Reline)
+
+      Reline::LineEditor.prepend(GirbLineEditorExtension)
+
+      # Ctrl+Space (ASCII 0) にバインド
+      Reline.core.config.add_default_key_binding_by_keymap(:emacs, [0], :girb_send_to_ai)
+      Reline.core.config.add_default_key_binding_by_keymap(:vi_insert, [0], :girb_send_to_ai)
+    end
+  end
+
+  module GirbLineEditorExtension
+    def girb_send_to_ai(_key)
+      Girb.ai_send_pending = true
+      finish
+    end
+  end
+
+  module EvalHook
+    def evaluate_expression(code, line_no)
+      code = code.to_s
+
+      # Ctrl+Space でAI送信された場合
+      if Girb.ai_send_pending?
+        Girb.ai_send_pending = false
+        question = code.strip
+        return if question.empty?
+
+        SessionHistory.record(line_no, question, is_ai_question: true)
+        ask_ai(question, line_no)
+        return
+      end
+
+      # 通常のRubyコード実行時はセッション履歴に記録
+      SessionHistory.record(line_no, code)
+      super
+    end
+
+    private
+
+    def ask_ai(question, line_no)
+      context = ContextBuilder.new(workspace.binding, self).build
+      client = AiClient.new
+      client.ask(question, context, binding: workspace.binding, line_no: line_no)
+    rescue StandardError => e
+      puts "[girb] Error: #{e.message}"
+    end
+  end
+end