girb 0.2.0 → 0.3.1

data/lib/girb/debug_integration.rb

@@ -4,11 +4,17 @@ require "debug"
 require_relative "debug_context_builder"
 require_relative "debug_prompt_builder"
 require_relative "debug_session_history"
+require_relative "session_persistence"
 
 module Girb
   module DebugIntegration
+    # Define at module level so it's accessible as Girb::DebugIntegration::GIRB_DIR
+    # Points to lib directory, not gem root, so user's files aren't filtered
+    GIRB_DIR = File.expand_path('..', __dir__)
+
     @ai_triggered = false
     @interrupted = false
+    @session_started = false
 
     class << self
       attr_accessor :ai_triggered, :auto_continue, :interrupted, :api_thread
@@ -43,13 +49,57 @@ module Girb
         @interrupted = false
       end
 
+      def session_started?
+        @session_started
+      end
+
+      def start_session!
+        return if @session_started
+
+        SessionPersistence.start_session
+        @session_started = true
+        setup_exit_hook
+      end
+
+      def save_session!
+        SessionPersistence.save_session if @session_started
+      end
+
       def setup
         return unless defined?(DEBUGGER__::SESSION)
+        return if @setup_done
 
         register_ai_command
         register_debug_tools
         setup_keybinding
-        puts "[girb] Debug AI assistant loaded. Use 'ai <question>' or Ctrl+Space."
+        patch_debugger_frame_filter
+        @setup_done = true
+        puts "[girb] Debug AI assistant loaded. Use 'qq <question>' or Ctrl+Space."
+      end
+
+      def patch_debugger_frame_filter
+        return unless defined?(DEBUGGER__)
+        return if @frame_filter_patched
+
+        # girbのフレームもdebuggerのスタックトレースから除外
+        if DEBUGGER__.respond_to?(:capture_frames)
+          original_method = DEBUGGER__.method(:capture_frames)
+          DEBUGGER__.define_singleton_method(:capture_frames) do |*args|
+            frames = original_method.call(*args)
+            frames.reject! do |frame|
+              frame.realpath&.start_with?(Girb::DebugIntegration::GIRB_DIR)
+            end
+            frames
+          end
+        end
+
+        @frame_filter_patched = true
+      end
+
+      # IRBからdebugモードに入った時に呼ばれる
+      def setup_if_needed
+        return if @setup_done
+        setup
       end
 
       private
@@ -75,12 +125,29 @@ module Girb
 
         Reline.core.config.add_default_key_binding_by_keymap(:emacs, [0], :girb_debug_ai_prefix)
       end
+
+      def setup_exit_hook
+        at_exit do
+          Girb::DebugIntegration.save_session!
+        end
+      end
     end
 
     module GirbDebugCommands
       MAX_AUTO_CONTINUE = 20
 
       def wait_command
+        # First, check for any pending commands (e.g., injected qq commands from IRB mode transition)
+        # Process these before entering auto_continue or waiting for user input
+        pending_cmds = Girb::DebugIntegration.take_pending_debug_commands
+        if pending_cmds.any?
+          pending_cmds.each do |cmd|
+            result = process_command(cmd)
+            return result unless result == :retry
+          end
+          return :retry
+        end
+
         if Girb::DebugIntegration.auto_continue?
           @girb_auto_continue_count ||= 0
           @girb_auto_continue_count += 1
@@ -133,9 +200,9 @@ module Girb
             return :retry
           end
 
-          pending_cmds = Girb::DebugIntegration.take_pending_debug_commands
-          if pending_cmds.any?
-            pending_cmds.each do |cmd|
+          more_cmds = Girb::DebugIntegration.take_pending_debug_commands
+          if more_cmds.any?
+            more_cmds.each do |cmd|
               result = process_command(cmd)
               return result unless result == :retry
             end
@@ -170,10 +237,16 @@ module Girb
           return :retry
         end
 
-        if line.start_with?("ai ")
-          question = line.sub(/^ai\s+/, "").strip
+        if line.start_with?("qq ")
+          question = line.sub(/^qq\s+/, "").strip
           return :retry if question.empty?
 
+          # セッション管理コマンド
+          if question.start_with?("session ")
+            handle_session_command(question.sub(/^session\s+/, ""))
+            return :retry
+          end
+
           Girb::DebugSessionHistory.record_ai_question(question)
           handle_ai_question(question)
           pending_cmds = Girb::DebugIntegration.take_pending_debug_commands
@@ -220,7 +293,10 @@ module Girb
         context = Girb::DebugContextBuilder.new(current_binding).build
         client = Girb::AiClient.new
         continuation = "(auto-continue: The debug command has been executed. Analyze the new state and continue your task.)"
-        client.ask(continuation, context, binding: current_binding, debug_mode: true)
+        # Disable Ruby's Timeout during API call to avoid deadlock with debug gem's threading
+        with_timeout_disabled do
+          client.ask(continuation, context, binding: current_binding, debug_mode: true)
+        end
       rescue StandardError => e
         @ui.puts "[girb] Auto-continue error: #{e.message}"
         Girb::DebugIntegration.auto_continue = false
@@ -234,14 +310,54 @@ module Girb
           return
         end
 
+        # 初回のAI質問時にセッションを開始
+        Girb::DebugIntegration.start_session!
+
+        # Ctrl+Cでプロセスがクラッシュするのを防ぐ
+        # trapハンドラを設置し、SIGINTをフラグ設定のみに抑える
+        original_handler = trap("INT") do
+          Girb::DebugIntegration.interrupt!
+        end
+
         context = Girb::DebugContextBuilder.new(current_binding).build
         client = Girb::AiClient.new
-        client.ask(question, context, binding: current_binding, debug_mode: true)
+        # Disable Ruby's Timeout during API call to avoid deadlock with debug gem's threading
+        with_timeout_disabled do
+          client.ask(question, context, binding: current_binding, debug_mode: true)
+        end
+
+        # API呼び出し後にinterruptチェック
+        if Girb::DebugIntegration.interrupted?
+          Girb::DebugIntegration.clear_interrupt!
+          Girb::DebugIntegration.auto_continue = false
+          Girb::DebugIntegration.take_pending_debug_commands
+          puts "\n[girb] Interrupted by user (Ctrl+C)"
+        end
       rescue Girb::ConfigurationError => e
         puts "[girb] #{e.message}"
       rescue StandardError => e
         puts "[girb] Error: #{e.message}"
         puts e.backtrace.first(3).join("\n") if Girb.configuration.debug
+      ensure
+        if original_handler
+          trap("INT", original_handler)
+        else
+          trap("INT", "DEFAULT")
+        end
+      end
+
+      # Temporarily disable Ruby's Timeout module to avoid deadlock with debug gem
+      # The underlying socket has its own timeout, so this is safe
+      def with_timeout_disabled
+        return yield unless defined?(Timeout)
+
+        original_timeout = Timeout.method(:timeout)
+        Timeout.define_singleton_method(:timeout) do |_sec, _klass = nil, _message = nil, &block|
+          block.call
+        end
+        yield
+      ensure
+        Timeout.define_singleton_method(:timeout, original_timeout) if original_timeout
       end
 
       def handle_ai_turn_limit_reached
@@ -254,7 +370,9 @@ module Girb
                         "Summarize your progress so far and tell the user what was accomplished. " \
                         "If the task is not complete, explain what remains and instruct the user " \
                         "to continue with a follow-up request.)"
-        client.ask(limit_message, context, binding: current_binding, debug_mode: true)
+        with_timeout_disabled do
+          client.ask(limit_message, context, binding: current_binding, debug_mode: true)
+        end
       rescue StandardError => e
         puts "[girb] Auto-continue limit reached (#{MAX_AUTO_CONTINUE})"
         puts "[girb] Error summarizing: #{e.message}" if Girb.configuration.debug
@@ -270,7 +388,9 @@ module Girb
         interrupt_message = "(System: User interrupted with Ctrl+C. " \
                             "Briefly summarize your progress so far. " \
                             "Tell the user where you stopped and how to continue if needed.)"
-        client.ask(interrupt_message, context, binding: current_binding, debug_mode: true)
+        with_timeout_disabled do
+          client.ask(interrupt_message, context, binding: current_binding, debug_mode: true)
+        end
       rescue StandardError => e
         puts "[girb] Error summarizing: #{e.message}" if Girb.configuration.debug
       end
@@ -293,6 +413,34 @@ module Girb
           trap("INT", "DEFAULT")
         end
       end
+
+      def handle_session_command(cmd)
+        case cmd.strip
+        when "clear"
+          Girb::SessionPersistence.clear_session
+        when "list"
+          sessions = Girb::SessionPersistence.list_sessions
+          if sessions.empty?
+            puts "[girb] No saved sessions"
+          else
+            puts "[girb] Saved sessions:"
+            sessions.each do |s|
+              puts "  - #{s[:id]} (#{s[:message_count]} messages, saved: #{s[:saved_at]})"
+            end
+          end
+        when "status"
+          if Girb::SessionPersistence.current_session_id
+            puts "[girb] Current session: #{Girb::SessionPersistence.current_session_id}"
+          elsif Girb.debug_session
+            puts "[girb] Session configured: #{Girb.debug_session} (not started)"
+          else
+            puts "[girb] No session configured (use Girb.debug_session = 'name' to enable)"
+          end
+        else
+          puts "[girb] Unknown session command: #{cmd}"
+          puts "[girb] Available: clear, list, status"
+        end
+      end
     end
   end
 end

data/lib/girb/debug_prompt_builder.rb

@@ -42,17 +42,77 @@ module Girb
       - Instance variables: `@x_values = []` then `@x_values << x`
       - Global variables: `$x_values = []` then `$x_values << x`
 
-      Example for tracking a variable's history efficiently:
-      1. `evaluate_code("$tracked = []")`
-      2. Use a "silent" breakpoint that records but doesn't stop:
-         `break file.rb:11 if: ($tracked << x; false)`
-         This appends x to $tracked and returns false, so execution continues without stopping.
-      3. Set a normal breakpoint at the END of the script to see results:
-         `break file.rb:14`
-      4. `continue` to run through all iterations
-      5. At the final breakpoint: `evaluate_code("$tracked")` to see all values
-
-      This approach is much more efficient than stopping at every iteration!
+      ## Efficiency: Prefer Conditional Breakpoints for Loops
+      When tracking variables through many iterations (loops, recursion), avoid repeated `next`/`step`
+      commands. Each step requires an API call, which is slow. Use conditional breakpoints instead:
+
+      **CRITICAL: Breakpoint Line Placement Rules**
+      Before setting a breakpoint, use `read_file` to verify the target line.
+      - NEVER place a breakpoint on a block header line (a line containing `do |...|`, `.each`, `.map`, `.times`, etc.).
+        Block header lines execute only ONCE when the method is called, so the breakpoint will only hit once.
+      - ALWAYS place breakpoints on a line INSIDE the block body. Block body lines execute on every iteration.
+      - Example:
+        ```
+        10: data.each_with_index do |val, i|   # BAD: this line hits only once
+        11:   x = (x * val + i * 3) % 100      # GOOD: this line hits every iteration
+        12: end
+        ```
+        Use `break file.rb:11` (body line), NOT `break file.rb:10` (header line).
+
+      **Efficient approach for loops with many iterations:**
+      1. `read_file` to check the source and identify the correct body line (not a block header)
+      2. `evaluate_code("$tracked = []")` - initialize tracking array
+      3. Use a conditional breakpoint on a block BODY line that records AND stops on condition:
+         `break file.rb:11 if: ($tracked << x; x == 1)`
+         This appends x to $tracked on EVERY iteration, but only stops when x == 1.
+      4. CRITICAL: In the SAME tool call batch, call `run_debug_command("c")` with `auto_continue: true`.
+         You MUST continue immediately after setting the breakpoint — do NOT stop and wait for user input.
+         When the breakpoint hits, you will be re-invoked with the new context.
+      5. When re-invoked after the breakpoint hits: `evaluate_code("$tracked")` to retrieve results,
+         then report the findings to the user.
+
+      Steps 3 and 4 MUST happen in the same turn. Example tool calls in one response:
+      - `run_debug_command("break file.rb:11 if: ($tracked << x; x == 1)")`
+      - `run_debug_command("c", auto_continue: true)`
+
+      This completes in 3-4 API turns instead of many turns with repeated stepping.
+
+      **Alternative: evaluate_code for pure tracking scenarios**
+      When the goal is purely to collect variable values and stop on a condition (without needing
+      to interact at the breakpoint), `evaluate_code` can run the loop directly. This is simpler
+      and avoids breakpoint line selection issues entirely:
+      ```ruby
+      evaluate_code <<~RUBY
+        $tracked = [x]
+        catch(:girb_stop) do
+          data.each_with_index do |val, i|
+            x = (x * val + i * 3) % 100
+            $tracked << x
+            throw(:girb_stop) if x == 1
+          end
+        end
+        { tracked_values: $tracked, stopped: (x == 1) }
+      RUBY
+      ```
+      Use this when the user wants to collect values and find when a condition is met,
+      and you can reconstruct the loop logic from the source code.
+
+      **When to use repeated stepping (next/step):**
+      - Understanding complex logic flow (few lines)
+      - Checking which branch is taken
+      - Loops with only 2-3 iterations
+      - User explicitly wants to see execution step by step
+
+      **When to use conditional breakpoints:**
+      - Loops with many iterations (5+)
+      - "Track variable X until condition Y" requests
+      - "Find when X becomes Y" requests
+      - Collecting history of values
+
+      **When to use evaluate_code loop:**
+      - Pure value tracking without needing to stop and interact
+      - When you can reconstruct the loop logic from source code
+      - When breakpoint placement is complex (nested blocks, etc.)
 
       ## CRITICAL: Executing Debugger Commands
       When the user asks you to perform a debugging action (e.g., "go to the next line", "step into",

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/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, 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