girb 0.1.2 → 0.3.0

data/lib/girb/debug_session_history.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Girb
+  # デバッグセッション中の入力とAI会話を管理するクラス
+  class DebugSessionHistory
+    Entry = Struct.new(:type, :content, :response, :timestamp, keyword_init: true)
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def reset!
+        @instance = new
+      end
+
+      # 委譲メソッド
+      def record_command(command)
+        instance.record_command(command)
+      end
+
+      def record_ai_question(question)
+        instance.record_ai_question(question)
+      end
+
+      def record_ai_response(response)
+        instance.record_ai_response(response)
+      end
+
+      def entries
+        instance.entries
+      end
+
+      def recent(count = 20)
+        instance.recent(count)
+      end
+
+      def ai_conversations
+        instance.ai_conversations
+      end
+
+      def format_history(count = 20)
+        instance.format_history(count)
+      end
+    end
+
+    attr_reader :entries
+
+    def initialize
+      @entries = []
+      @pending_ai_entry = nil
+    end
+
+    # デバッガーコマンドを記録
+    def record_command(command)
+      return if command.nil? || command.strip.empty?
+
+      @entries << Entry.new(
+        type: :command,
+        content: command.strip,
+        response: nil,
+        timestamp: Time.now
+      )
+    end
+
+    # AI質問を記録（回答は後から追加）
+    def record_ai_question(question)
+      entry = Entry.new(
+        type: :ai_question,
+        content: question,
+        response: nil,
+        timestamp: Time.now
+      )
+      @entries << entry
+      @pending_ai_entry = entry
+    end
+
+    # AI回答を記録
+    def record_ai_response(response)
+      if @pending_ai_entry
+        @pending_ai_entry.response = response
+        @pending_ai_entry = nil
+      end
+    end
+
+    # 最近のエントリを取得
+    def recent(count = 20)
+      @entries.last(count)
+    end
+
+    # AI会話のみを取得
+    def ai_conversations
+      @entries.select { |e| e.type == :ai_question && e.response }
+    end
+
+    # フォーマットされた履歴を取得
+    def format_history(count = 20)
+      recent(count).map do |entry|
+        case entry.type
+        when :command
+          "[cmd] #{entry.content}"
+        when :ai_question
+          if entry.response
+            response_preview = truncate(entry.response, 150)
+            "[ai] Q: #{entry.content}\n     A: #{response_preview}"
+          else
+            "[ai] Q: #{entry.content} (pending...)"
+          end
+        end
+      end.join("\n")
+    end
+
+    private
+
+    def truncate(str, max_length)
+      return str if str.nil?
+
+      str.length > max_length ? "#{str[0, max_length]}..." : str
+    end
+  end
+end

data/lib/girb/exception_capture.rb

@@ -35,6 +35,10 @@ module Girb
           next if tp.path&.include?("readline")
           next if tp.path&.include?("rdoc")
           next if tp.path&.include?("/ri/")
+          # forwardableは内部でSyntaxErrorを意図的に発生させてrescueする
+          next if tp.path&.include?("forwardable")
+          # rubygemsのrequireは最初にLoadErrorを発生させてからgemをアクティベートする
+          next if tp.path&.include?("rubygems")
           next if tp.raised_exception.is_a?(SystemExit)
           next if tp.raised_exception.is_a?(Interrupt)
           # ErrorHighlight内部の例外を除外

data/lib/girb/girbrc_loader.rb

@@ -5,25 +5,31 @@ require "pathname"
 module Girb
   module GirbrcLoader
     class << self
-      # Find .girbrc by traversing from start_dir up to root,
-      # then fall back to ~/.girbrc
-      def find_girbrc(start_dir = Dir.pwd)
+      # Find config file by traversing from start_dir up to root,
+      # then fall back to home directory
+      def find_config(filename, start_dir = Dir.pwd)
         dir = Pathname.new(start_dir).expand_path
 
-        # Traverse up to find .girbrc
+        # Traverse up to find config file
         while dir != dir.parent
-          candidate = dir.join(".girbrc")
+          candidate = dir.join(filename)
           return candidate if candidate.exist?
           dir = dir.parent
         end
 
         # Check root directory
-        root_candidate = dir.join(".girbrc")
+        root_candidate = dir.join(filename)
         return root_candidate if root_candidate.exist?
 
-        # Fall back to ~/.girbrc
-        home_girbrc = Pathname.new(File.expand_path("~/.girbrc"))
-        home_girbrc.exist? ? home_girbrc : nil
+        # Fall back to home directory
+        home_config = Pathname.new(File.expand_path("~/#{filename}"))
+        home_config.exist? ? home_config : nil
+      end
+
+      # Find .girbrc by traversing from start_dir up to root,
+      # then fall back to ~/.girbrc
+      def find_girbrc(start_dir = Dir.pwd)
+        find_config(".girbrc", start_dir)
       end
 
       # Load .girbrc if found

data/lib/girb/irb_integration.rb

@@ -5,9 +5,42 @@ require "irb/command"
 require_relative "exception_capture"
 require_relative "context_builder"
 require_relative "session_history"
+require_relative "session_persistence"
+require_relative "auto_continue"
 require_relative "ai_client"
 
 module Girb
+  # IRB::Debug.setupをフックして、debug gem初期化後にgirb統合をセットアップ
+  module IrbDebugHook
+    def setup(irb)
+      result = super
+      if result && defined?(DEBUGGER__::SESSION)
+        # DebugIntegrationを動的に読み込む
+        require_relative "debug_integration" unless defined?(Girb::DebugIntegration)
+        Girb::DebugIntegration.setup_if_needed
+
+        # Instead of using auto_continue (which causes deadlocks with API calls),
+        # inject a qq command to continue the conversation through normal command flow
+        if defined?(Girb::AutoContinue) && Girb::AutoContinue.active?
+          Girb::AutoContinue.reset!
+          # Include original user question so AI remembers the task
+          original_question = Girb::IrbIntegration.pending_user_question
+          Girb::IrbIntegration.pending_user_question = nil
+          if original_question
+            continuation = "(auto-continue: デバッグモードに移行しました。最初のデバッグコマンドは既に実行されました。" \
+                           "同じコマンドを再度発行しないでください。\n" \
+                           "元の指示: 「#{original_question}」\n" \
+                           "次のステップに進んでください。例: continueで実行を継続、または結果を確認。)"
+          else
+            continuation = "(auto-continue: デバッグモードに移行しました。最初のデバッグコマンドは既に実行されました。" \
+                           "次のステップに進んでください。)"
+          end
+          Girb::DebugIntegration.add_pending_debug_command("qq #{continuation}")
+        end
+      end
+      result
+    end
+  end
   # AI送信フラグ（スレッドローカル）
   def self.ai_send_pending?
     Thread.current[:girb_ai_send_pending]
@@ -18,6 +51,83 @@ module Girb
   end
 
   module IrbIntegration
+    @session_started = false
+    @exit_hook_installed = false
+    @pending_irb_commands = []
+    @pending_input_commands = []
+    @auto_continue = false
+
+    DEBUG_COMMANDS = %w[next n step s continue c finish break delete backtrace bt info catch debug].freeze
+
+    class << self
+      attr_accessor :auto_continue
+
+      def pending_irb_commands
+        @pending_irb_commands ||= []
+      end
+
+      def add_pending_irb_command(cmd)
+        pending_irb_commands << cmd
+      end
+
+      def take_pending_irb_commands
+        cmds = @pending_irb_commands || []
+        @pending_irb_commands = []
+        cmds
+      end
+
+      # Commands to be injected into IRB's input stream
+      def pending_input_commands
+        @pending_input_commands ||= []
+      end
+
+      def add_pending_input_command(cmd)
+        pending_input_commands << cmd
+      end
+
+      def take_next_input_command
+        @pending_input_commands ||= []
+        @pending_input_commands.shift
+      end
+
+      def has_pending_input?
+        @pending_input_commands && !@pending_input_commands.empty?
+      end
+
+      def debug_command?(cmd)
+        name = cmd.strip.split(/\s+/, 2).first&.downcase
+        DEBUG_COMMANDS.include?(name)
+      end
+
+      def auto_continue?
+        @auto_continue
+      end
+
+      # Store the original user question for continuation after debug mode transition
+      attr_accessor :pending_user_question
+
+      def session_started?
+        @session_started
+      end
+
+      def start_session!
+        return if @session_started
+        return unless SessionPersistence.enabled?
+
+        SessionPersistence.start_session
+        @session_started = true
+        setup_exit_hook unless @exit_hook_installed
+      end
+
+      def save_session!
+        return unless @session_started
+        SessionPersistence.save_session
+      rescue => e
+        # exit時のエラーは静かに無視
+        STDERR.puts "[girb] Warning: Failed to save session: #{e.message}" if ENV["GIRB_DEBUG"]
+      end
+    end
+
     def self.setup
       # コマンドを登録
       require_relative "../irb/command/qq"
@@ -30,6 +140,39 @@ module Girb
 
       # Ctrl+Space キーバインドをインストール
       install_ai_keybinding
+
+      # readmultiline パッチをインストール（コマンド注入用）
+      install_readmultiline_patch
+
+      # セッション永続化が有効なら開始
+      start_session! if SessionPersistence.enabled?
+
+      # IRB::Debugをフックして、debug開始時にgirb統合をセットアップ
+      install_debug_hook
+    end
+
+    def self.install_debug_hook
+      return if @debug_hook_installed
+      return unless defined?(IRB::Debug)
+
+      IRB::Debug.singleton_class.prepend(Girb::IrbDebugHook)
+      @debug_hook_installed = true
+    end
+
+    def self.install_readmultiline_patch
+      return if @readmultiline_patch_installed
+
+      IRB::Irb.prepend(ReadmultilinePatch)
+      @readmultiline_patch_installed = true
+    end
+
+    def self.setup_exit_hook
+      return if @exit_hook_installed
+      @exit_hook_installed = true
+
+      at_exit do
+        Girb::IrbIntegration.save_session!
+      end
     end
 
     def self.install_eval_hook
@@ -77,11 +220,100 @@ module Girb
     private
 
     def ask_ai(question, line_no)
+      # Store the question for continuation after debug mode transition
+      Girb::IrbIntegration.pending_user_question = question
+
       context = ContextBuilder.new(workspace.binding, self).build
       client = AiClient.new
-      client.ask(question, context, binding: workspace.binding, line_no: line_no)
+      client.ask(question, context, binding: workspace.binding, line_no: line_no, irb_context: self)
+
+      # Execute any pending IRB commands after AI response
+      execute_pending_commands
     rescue StandardError => e
       puts "[girb] Error: #{e.message}"
     end
+
+    def execute_pending_commands
+      commands = Girb::IrbIntegration.take_pending_irb_commands
+      return if commands.empty?
+
+      commands.each do |cmd|
+        if Girb::IrbIntegration.debug_command?(cmd)
+          # Debug commands need to be processed at IRB's top level
+          # Queue them for injection via readmultiline patch
+          puts "[girb] Queuing debug command: #{cmd}"
+          Girb::IrbIntegration.add_pending_input_command(cmd)
+        else
+          # Non-debug commands can be executed directly
+          puts "[girb] Executing: #{cmd}"
+          begin
+            execute_irb_command(cmd)
+          rescue StandardError => e
+            puts "[girb] Command error: #{e.message}"
+          end
+        end
+      end
+    end
+
+    def execute_irb_command(cmd)
+      # Parse command and arguments
+      parts = cmd.strip.split(/\s+/, 2)
+      command_name = parts[0]
+      arg = parts[1] || ""
+
+      # Map command names to IRB command classes
+      command_class = find_irb_command_class(command_name)
+
+      if command_class
+        command_class.execute(self, arg)
+      else
+        # Fall back to evaluating as Ruby code
+        evaluate_expression(cmd, 0)
+      end
+    end
+
+    def find_irb_command_class(name)
+      # Debug-related command mappings
+      command_map = {
+        "next" => "Next", "n" => "Next",
+        "step" => "Step", "s" => "Step",
+        "continue" => "Continue", "c" => "Continue",
+        "finish" => "Finish",
+        "break" => "Break",
+        "delete" => "Delete",
+        "backtrace" => "Backtrace", "bt" => "Backtrace",
+        "info" => "Info",
+        "catch" => "Catch",
+        "debug" => "Debug"
+      }
+
+      class_name = command_map[name.downcase]
+      return nil unless class_name
+
+      begin
+        IRB::Command.const_get(class_name)
+      rescue NameError
+        nil
+      end
+    end
+  end
+
+  # Patch to inject pending commands into IRB's input stream
+  # This ensures debug commands are processed at the top level of IRB's loop
+  module ReadmultilinePatch
+    def readmultiline
+      # Check for pending commands from girb AI
+      if (cmd = Girb::IrbIntegration.take_next_input_command)
+        puts "[girb] Injecting command: #{cmd}"
+        # Return command with newline so it's processed as complete input
+        return cmd.end_with?("\n") ? cmd : "#{cmd}\n"
+      end
+
+      result = super
+
+      # After debug command executes and we transition to debug mode,
+      # the debug_integration auto_continue mechanism takes over
+      result
+    end
   end
 end