girb 0.1.2 → 0.3.0

data/lib/girb/debug_integration.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+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
+
+      def pending_debug_commands
+        @pending_debug_commands ||= []
+      end
+
+      def add_pending_debug_command(cmd)
+        pending_debug_commands << cmd
+      end
+
+      def take_pending_debug_commands
+        cmds = @pending_debug_commands || []
+        @pending_debug_commands = []
+        cmds
+      end
+
+      def auto_continue?
+        @auto_continue
+      end
+
+      def interrupted?
+        @interrupted
+      end
+
+      def interrupt!
+        @interrupted = true
+      end
+
+      def clear_interrupt!
+        @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
+        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
+
+      def register_ai_command
+        DEBUGGER__::SESSION.class.prepend(GirbDebugCommands)
+      end
+
+      def register_debug_tools
+        require_relative "tools/run_debug_command"
+        Girb::Tools.register(Girb::Tools::RunDebugCommand)
+      end
+
+      def setup_keybinding
+        return unless defined?(Reline::LineEditor)
+
+        Reline::LineEditor.prepend(Module.new do
+          private def girb_debug_ai_prefix(key)
+            Girb::DebugIntegration.ai_triggered = true
+            finish
+          end
+        end)
+
+        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
+
+          # Set up interrupt handler on first iteration
+          if @girb_auto_continue_count == 1
+            setup_interrupt_handler
+          end
+
+          # Check for interrupt (Ctrl+C)
+          if Girb::DebugIntegration.interrupted?
+            Girb::DebugIntegration.auto_continue = false
+            Girb::DebugIntegration.clear_interrupt!
+            @girb_auto_continue_count = 0
+            restore_interrupt_handler
+            handle_ai_interrupted
+            return :retry
+          end
+
+          if @girb_auto_continue_count > MAX_AUTO_CONTINUE
+            Girb::DebugIntegration.auto_continue = false
+            @girb_auto_continue_count = 0
+            restore_interrupt_handler
+            handle_ai_turn_limit_reached
+            return :retry
+          end
+
+          begin
+            handle_ai_continuation
+          rescue Exception => e
+            if e.is_a?(Interrupt) || e.class.name.include?("Interrupt") || e.class.name.include?("Abort")
+              Girb::DebugIntegration.auto_continue = false
+              Girb::DebugIntegration.clear_interrupt!
+              @girb_auto_continue_count = 0
+              restore_interrupt_handler
+              handle_ai_interrupted
+              return :retry
+            else
+              raise
+            end
+          end
+
+          # Check for interrupt after API call (Ctrl+C during request)
+          if Girb::DebugIntegration.interrupted?
+            Girb::DebugIntegration.auto_continue = false
+            Girb::DebugIntegration.clear_interrupt!
+            @girb_auto_continue_count = 0
+            restore_interrupt_handler
+            handle_ai_interrupted
+            return :retry
+          end
+
+          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
+          else
+            Girb::DebugIntegration.auto_continue = false
+            restore_interrupt_handler
+          end
+          return :retry
+        else
+          @girb_auto_continue_count = 0
+          Girb::DebugIntegration.clear_interrupt!
+        end
+
+        super
+      end
+
+      def process_command(line)
+        if Girb::DebugIntegration.ai_triggered
+          Girb::DebugIntegration.ai_triggered = false
+          question = line.strip
+          return :retry if question.empty?
+
+          Girb::DebugSessionHistory.record_ai_question(question)
+          handle_ai_question(question)
+          pending_cmds = Girb::DebugIntegration.take_pending_debug_commands
+          if pending_cmds.any?
+            pending_cmds.each do |cmd|
+              result = super(cmd)
+              return result unless result == :retry
+            end
+          end
+          return :retry
+        end
+
+        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
+          if pending_cmds.any?
+            pending_cmds.each do |cmd|
+              result = super(cmd)
+              return result unless result == :retry
+            end
+          end
+          return :retry
+        end
+
+        # Auto-detect natural language (non-ASCII input) and route to AI
+        if line.match?(/[^\x00-\x7F]/)
+          question = line.strip
+          return :retry if question.empty?
+
+          Girb::DebugSessionHistory.record_ai_question(question)
+          handle_ai_question(question)
+          pending_cmds = Girb::DebugIntegration.take_pending_debug_commands
+          if pending_cmds.any?
+            pending_cmds.each do |cmd|
+              result = super(cmd)
+              return result unless result == :retry
+            end
+          end
+          return :retry
+        end
+
+        # Record regular debugger commands
+        Girb::DebugSessionHistory.record_command(line)
+        super
+      end
+
+      private
+
+      def handle_ai_continuation
+        current_binding = @tc&.current_frame&.eval_binding
+        unless current_binding
+          @ui.puts "[girb] Error: No current frame available"
+          return
+        end
+
+        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.)"
+        # 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
+      end
+
+      def handle_ai_question(question)
+        current_binding = @tc&.current_frame&.eval_binding
+
+        unless current_binding
+          puts "[girb] Error: No current frame available"
+          return
+        end
+
+        # 初回のAI質問時にセッションを開始
+        Girb::DebugIntegration.start_session!
+
+        context = Girb::DebugContextBuilder.new(current_binding).build
+        client = Girb::AiClient.new
+        # 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
+      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
+      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
+        current_binding = @tc&.current_frame&.eval_binding
+        return unless current_binding
+
+        context = Girb::DebugContextBuilder.new(current_binding).build
+        client = Girb::AiClient.new
+        limit_message = "(System: Auto-continue turn limit (#{MAX_AUTO_CONTINUE}) reached. " \
+                        "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.)"
+        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
+      end
+
+      def handle_ai_interrupted
+        puts "\n[girb] Interrupted by user (Ctrl+C)"
+        current_binding = @tc&.current_frame&.eval_binding
+        return unless current_binding
+
+        context = Girb::DebugContextBuilder.new(current_binding).build
+        client = Girb::AiClient.new
+        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.)"
+        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
+
+      def setup_interrupt_handler
+        Girb::DebugIntegration.api_thread = Thread.current
+        @original_int_handler = trap("INT") do
+          Girb::DebugIntegration.interrupt!
+          # Raise Interrupt to break out of blocking IO operations
+          thread = Girb::DebugIntegration.api_thread
+          thread&.raise(Interrupt) if thread&.alive?
+        end
+      end
+
+      def restore_interrupt_handler
+        if @original_int_handler
+          trap("INT", @original_int_handler)
+          @original_int_handler = nil
+        else
+          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

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Girb
+  class DebugPromptBuilder
+    SYSTEM_PROMPT = <<~PROMPT
+      You are girb, an AI debugging assistant embedded in a Ruby debugger session.
+      You are integrated with Ruby's debug gem and can help developers debug their code.
+
+      ## CRITICAL: Context Information
+      The user is stopped at a breakpoint or debugger statement.
+      You have access to the current execution context including:
+      - Local variables and their values
+      - Instance variables of the current object
+      - The current file and line number
+      - The call stack (backtrace)
+
+      ## Language
+      Respond in the same language the user is using.
+
+      ## Your Role
+      - Help debug issues by analyzing the current state
+      - Explain what the code is doing and why it might be failing
+      - Use tools to inspect objects, evaluate code, or read source files
+      - Provide actionable advice to fix issues
+
+      ## When to Investigate Proactively
+      When the user asks about code, debugging, variables, errors, or anything related to their program,
+      you should investigate before responding:
+      - Use `read_file` to read the source file shown in "Source Location" if relevant to the question
+      - Use `evaluate_code` to run and verify code rather than guessing or reasoning about results
+      - NEVER ask the user for code, file names, or variable definitions that you can look up
+        yourself with `read_file`, `evaluate_code`, `inspect_object`, or `find_file`
+
+      However, for simple greetings or conversational messages (e.g., "hello", "hi", "こんにちは", "thanks"),
+      just respond naturally without using tools. Not every message requires investigation.
+
+      ## CRITICAL: Variable Persistence Across Frames
+      Local variables created via `evaluate_code` do NOT persist after `step`, `next`, or `continue`.
+      When the program moves to a new frame, those local variables are lost.
+
+      To track values across multiple breakpoints or frames, use:
+      - Instance variables: `@x_values = []` then `@x_values << x`
+      - Global variables: `$x_values = []` then `$x_values << x`
+
+      ## 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:
+
+      **Efficient approach for loops with many iterations:**
+      1. `evaluate_code("$tracked = []")` - initialize tracking array
+      2. Use a conditional breakpoint that records AND stops on condition:
+         `break file.rb:10 if: ($tracked << x; x == 1)`
+         This appends x to $tracked on EVERY hit, but only stops when x == 1.
+      3. `continue` - run through all iterations at full speed
+      4. When stopped (or at end): `evaluate_code("$tracked")` to see all collected values
+
+      This completes in 2-3 API turns instead of many turns with repeated stepping.
+
+      **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
+
+      ## CRITICAL: Executing Debugger Commands
+      When the user asks you to perform a debugging action (e.g., "go to the next line", "step into",
+      "continue", "advance to line N", "set a breakpoint"), you MUST use the `run_debug_command` tool.
+      Do NOT just print or suggest the command as text — actually call the tool.
+      You can also use the `evaluate_code` tool to run Ruby expressions in the current context.
+
+      Available debugger commands for run_debug_command:
+      - `step` / `s`: Step into method calls
+      - `next` / `n`: Step over to next line
+      - `continue` / `c`: Continue execution
+      - `finish`: Run until current method returns
+      - `up` / `down`: Navigate the call stack
+      - `break <file>:<line>`: Set a breakpoint (e.g., `break sample.rb:14`)
+      - `info locals`: Show local variables
+      - `pp <expr>`: Pretty print an expression
+
+      IMPORTANT: For conditional breakpoints, use `if:` (with colon), NOT `if` (without colon).
+      Example: `break sample.rb:14 if: x == 1`
+
+      IMPORTANT: Each `run_debug_command` call must contain exactly ONE debugger command.
+      NEVER combine multiple commands with `;` or append debugger commands to breakpoint conditions.
+      BAD:  `break sample.rb:14 if: x == 1; continue` ("; continue" becomes part of the Ruby condition and causes an error)
+      GOOD: Call `run_debug_command("break sample.rb:14 if: x == 1")` then `run_debug_command("c")` separately.
+
+      ## Response Guidelines
+      - Keep responses concise and actionable
+      - Focus on the immediate debugging task
+      - When the user requests a debugger action, execute it via run_debug_command — do not just describe it
+      - NEVER repeat the same failed action. If a tool call fails, analyze the error and try a different approach
+      - If you encounter an error about undefined variables after continue/step, remember to use instance or global variables
+      - IMPORTANT: When a task is complete (tracking finished, script ended, etc.), ALWAYS report the results.
+        Don't just execute commands and stop — check the collected data and summarize findings for the user.
+        For example, after tracking variables: use evaluate_code to retrieve $tracked and present the results.
+
+      ## Available Tools
+      Use tools to inspect the runtime state:
+      - evaluate_code: Execute Ruby code in the current context
+      - inspect_object: Get detailed information about objects
+      - get_source: Read method or class source code
+      - list_methods: List available methods on an object
+      - read_file: Read source files
+      - find_file: Find files in the project
+      - get_session_history: Get past debugger commands and AI conversations
+      - run_debug_command: Execute a debugger command (n, s, c, finish, up, down, break, info, bt, etc.)
+
+      ## Session History
+      The "Session History" section in the context shows recent debugger commands and AI conversations.
+      Use this to understand the user's past actions and questions. Format:
+      - [cmd] ... : Debugger command entered by user
+      - [ai] Q: ... A: ... : Previous AI question and response
+
+      ## Interactive Debugging with auto_continue
+      When you need to execute a debugger command AND see the result before deciding your next action,
+      use `run_debug_command` with `auto_continue: true`.
+
+      After the command executes and the program stops at a new point, you will be automatically
+      re-invoked with the updated debug context (new file/line, new variable values).
+      You can then inspect variables, evaluate code, and decide whether to continue stepping or
+      give your final answer.
+
+      Use `auto_continue: true` when:
+      - Stepping through code to find where a variable changes
+      - Continuing to a breakpoint and then analyzing the state
+      - Any scenario where you need to see the result of a navigation command
+      - When the user asks you to track/collect data and report results — you need to be re-invoked
+        after the program stops so you can check the collected data and report back
+
+      Do NOT use `auto_continue: true` when:
+      - You've already collected and reported all the information the user asked for
+      - The user explicitly asks to just run a command without analysis
+
+      You can call `run_debug_command` multiple times in a single turn to batch commands.
+      Non-navigation commands (break, info, bt) should come before navigation commands (step, next, continue).
+    PROMPT
+
+    def initialize(question, context)
+      @question = question
+      @context = context
+    end
+
+    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
+
+    def user_message
+      <<~MSG
+        ## Current Debug Context
+        #{build_context_section}
+
+        ## Question
+        #{@question}
+      MSG
+    end
+
+    private
+
+    def build_context_section
+      <<~CONTEXT
+        ### Source Location
+        #{format_source_location}
+
+        ### Local Variables
+        #{format_locals}
+
+        ### Instance Variables
+        #{format_instance_variables}
+
+        ### Current Object (self)
+        #{format_self_info}
+
+        ### Backtrace
+        #{format_backtrace}
+
+        ### Session History (recent commands and AI conversations)
+        #{format_session_history}
+      CONTEXT
+    end
+
+    def format_source_location
+      loc = @context[:source_location]
+      return "(unknown)" unless loc
+
+      "File: #{loc[:file]}\nLine: #{loc[:line]}"
+    end
+
+    def format_locals
+      locals = @context[:local_variables]
+      return "(none)" if locals.nil? || locals.empty?
+
+      locals.map { |name, value| "- #{name}: #{value}" }.join("\n")
+    end
+
+    def format_instance_variables
+      ivars = @context[:instance_variables]
+      return "(none)" if ivars.nil? || ivars.empty?
+
+      ivars.map { |name, value| "- #{name}: #{value}" }.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_backtrace
+      bt = @context[:backtrace]
+      return "(not available)" unless bt
+
+      bt
+    end
+
+    def format_session_history
+      history = @context[:session_history]
+      return "(no history yet)" if history.nil? || history.empty?
+
+      history
+    end
+  end
+end