girb 0.1.2 → 0.3.0

data/lib/girb/ai_client.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "auto_continue"
 require_relative "conversation_history"
 require_relative "providers/base"
+require_relative "debug_context_builder"
+require_relative "debug_prompt_builder"
 
 module Girb
   class AiClient
@@ -11,23 +14,100 @@ module Girb
       @provider = Girb.configuration.provider!
     end
 
-    def ask(question, context, binding: nil, line_no: nil)
+    def ask(question, context, binding: nil, line_no: nil, irb_context: nil, debug_mode: false)
       @current_binding = binding
       @current_line_no = line_no
+      @irb_context = irb_context
+      @debug_mode = debug_mode
       @reasoning_log = []
 
-      prompt_builder = PromptBuilder.new(question, context)
+      prompt_builder = create_prompt_builder(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)
+
+      # In debug mode, auto-continue is handled by DebugIntegration, not here
+      if @debug_mode
+        process_with_tools(tools)
+      else
+        auto_continue_count = 0
+        original_int_handler = setup_interrupt_handler
+        @debug_command_queued = false
+
+        begin
+          loop do
+            # Check for interrupt at start of loop
+            if Girb::AutoContinue.interrupted?
+              Girb::AutoContinue.clear_interrupt!
+              handle_irb_interrupted
+              break
+            end
+
+            process_with_tools(tools)
+
+            # If a debug command was queued, exit immediately
+            # The command needs to be executed by IRB first, then DebugIntegration handles auto-continue
+            if @debug_command_queued
+              break
+            end
+
+            # Check for interrupt after API call (Ctrl+C during request)
+            if Girb::AutoContinue.interrupted?
+              Girb::AutoContinue.clear_interrupt!
+              handle_irb_interrupted
+              break
+            end
+
+            break unless Girb::AutoContinue.active?
+
+            auto_continue_count += 1
+            if auto_continue_count >= Girb::AutoContinue::MAX_ITERATIONS
+              handle_irb_limit_reached
+              break
+            end
+
+            Girb::AutoContinue.reset!
+
+            # Rebuild context with current binding state
+            new_context = create_context_builder(@current_binding, @irb_context).build
+            continuation = "(auto-continue: Your previous action has been completed. " \
+                           "Here is the updated context. Continue your investigation.)"
+            continuation_builder = create_prompt_builder(continuation, new_context)
+            ConversationHistory.add_user_message(continuation_builder.user_message)
+          end
+        ensure
+          restore_interrupt_handler(original_int_handler)
+          # Only reset AutoContinue if no debug command was queued
+          # (it will be transferred to DebugIntegration in IrbDebugHook)
+          unless @debug_command_queued
+            Girb::AutoContinue.reset!
+          end
+          Girb::AutoContinue.clear_interrupt!
+        end
+      end
     end
 
     private
 
+    def create_prompt_builder(question, context)
+      if @debug_mode
+        DebugPromptBuilder.new(question, context)
+      else
+        PromptBuilder.new(question, context)
+      end
+    end
+
+    def create_context_builder(binding, irb_context)
+      if @debug_mode
+        DebugContextBuilder.new(binding)
+      else
+        ContextBuilder.new(binding, irb_context)
+      end
+    end
+
     def build_tools
       Tools.available_tools.map do |tool_class|
         {
@@ -43,6 +123,12 @@ module Girb
       accumulated_text = []
 
       loop do
+        # Check for interrupt at start of each iteration
+        if check_interrupted?
+          puts "\n[girb] Interrupted by user (Ctrl+C)"
+          break
+        end
+
         iterations += 1
         if iterations > MAX_TOOL_ITERATIONS
           puts "\n[girb] Tool iteration limit reached"
@@ -50,12 +136,29 @@ module Girb
         end
 
         messages = ConversationHistory.to_normalized
-        response = @provider.chat(
-          messages: messages,
-          system_prompt: @system_prompt,
-          tools: tools,
-          binding: @current_binding
-        )
+        begin
+          response = @provider.chat(
+            messages: messages,
+            system_prompt: @system_prompt,
+            tools: tools,
+            binding: @current_binding
+          )
+        rescue Interrupt => e
+          puts "\n[girb] Interrupted by user (Ctrl+C)"
+          Girb::AutoContinue.interrupt! unless @debug_mode
+          Girb::DebugIntegration.interrupt! if @debug_mode && defined?(Girb::DebugIntegration)
+          break
+        rescue Exception => e
+          # IRB::Abort and similar exceptions
+          if e.class.name.include?("Abort") || e.class.name.include?("Interrupt")
+            puts "\n[girb] Interrupted by user (Ctrl+C)"
+            Girb::AutoContinue.interrupt! unless @debug_mode
+            Girb::DebugIntegration.interrupt! if @debug_mode && defined?(Girb::DebugIntegration)
+            break
+          else
+            raise
+          end
+        end
 
         if Girb.configuration.debug
           puts "[girb] function_calls: #{response.function_calls.inspect}"
@@ -79,27 +182,49 @@ module Girb
             accumulated_text << response.text
           end
 
-          function_call = response.function_calls.first
-          tool_name = function_call[:name]
-          tool_args = function_call[:args] || {}
+          debug_command_called = false
 
-          if Girb.configuration.debug
-            puts "[girb] Tool: #{tool_name}(#{tool_args.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')})"
-          end
+          response.function_calls.each do |function_call|
+            tool_name = function_call[:name]
+            tool_args = function_call[:args] || {}
+            tool_id = function_call[:id]
+
+            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)
 
-          result = execute_tool(tool_name, tool_args)
+            @reasoning_log << {
+              tool: tool_name,
+              args: tool_args,
+              result: result
+            }
 
-          @reasoning_log << {
-            tool: tool_name,
-            args: tool_args,
-            result: result
-          }
+            ConversationHistory.add_tool_call(tool_name, tool_args, result, id: tool_id)
 
-          # 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
 
-          if Girb.configuration.debug && result.is_a?(Hash) && result[:error]
-            puts "[girb] Tool error: #{result[:error]}"
+            # If run_debug_command was called, we need to exit the tool loop
+            # so the debugger/IRB can execute the pending commands
+            if tool_name == "run_debug_command"
+              debug_command_called = true
+              # In IRB mode, mark that we've queued a debug command
+              # This will prevent the auto-continue loop from continuing
+              @debug_command_queued = true unless @debug_mode
+            end
+          end
+
+          # Exit tool loop if debug command was called - let debugger take over
+          if debug_command_called
+            # Save accumulated text and pending tool calls as assistant message
+            text = accumulated_text.any? ? accumulated_text.join("\n") : ""
+            ConversationHistory.add_assistant_message(text)
+            record_ai_response(text) unless text.empty?
+            puts text unless text.empty?
+            break
           end
         else
           # Text response
@@ -140,10 +265,13 @@ module Girb
     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)
+      if @debug_mode
+        require_relative "debug_session_history"
+        DebugSessionHistory.record_ai_response(response)
+      elsif @current_line_no
+        reasoning = @reasoning_log.empty? ? nil : format_reasoning
+        SessionHistory.record_ai_response(@current_line_no, response, reasoning)
+      end
     end
 
     def format_reasoning
@@ -154,5 +282,57 @@ module Girb
         "Tool: #{log[:tool]}(#{args_str})\nResult: #{result_str}"
       end.join("\n\n")
     end
+
+    def setup_interrupt_handler
+      trap("INT") do
+        Girb::AutoContinue.interrupt!
+      end
+    end
+
+    def check_interrupted?
+      if @debug_mode
+        defined?(Girb::DebugIntegration) && Girb::DebugIntegration.interrupted?
+      else
+        Girb::AutoContinue.interrupted?
+      end
+    end
+
+    def restore_interrupt_handler(original_handler)
+      if original_handler
+        trap("INT", original_handler)
+      else
+        trap("INT", "DEFAULT")
+      end
+    end
+
+    def handle_irb_interrupted
+      return unless @current_binding
+
+      new_context = create_context_builder(@current_binding, @irb_context).build
+      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.)"
+      continuation_builder = create_prompt_builder(interrupt_message, new_context)
+      ConversationHistory.add_user_message(continuation_builder.user_message)
+      process_with_tools(build_tools)
+    rescue StandardError => e
+      puts "[girb] Error summarizing: #{e.message}" if Girb.configuration.debug
+    end
+
+    def handle_irb_limit_reached
+      puts "\n[girb] Auto-continue limit reached (#{Girb::AutoContinue::MAX_ITERATIONS})"
+      return unless @current_binding
+
+      new_context = create_context_builder(@current_binding, @irb_context).build
+      limit_message = "(System: Auto-continue limit (#{Girb::AutoContinue::MAX_ITERATIONS}) 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.)"
+      continuation_builder = create_prompt_builder(limit_message, new_context)
+      ConversationHistory.add_user_message(continuation_builder.user_message)
+      process_with_tools(build_tools)
+    rescue StandardError => e
+      puts "[girb] Error summarizing: #{e.message}" if Girb.configuration.debug
+    end
   end
 end

data/lib/girb/auto_continue.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Girb
+  module AutoContinue
+    MAX_ITERATIONS = 20
+
+    class << self
+      def active?
+        @active || false
+      end
+
+      def request!
+        @active = true
+      end
+
+      def reset!
+        @active = false
+      end
+
+      def interrupted?
+        @interrupted || false
+      end
+
+      def interrupt!
+        @interrupted = true
+      end
+
+      def clear_interrupt!
+        @interrupted = false
+      end
+    end
+  end
+end

data/lib/girb/conversation_history.rb

@@ -22,8 +22,8 @@ module Girb
         instance.add_assistant_message(content)
       end
 
-      def add_tool_call(tool_name, args, result)
-        instance.add_tool_call(tool_name, args, result)
+      def add_tool_call(tool_name, args, result, id: nil)
+        instance.add_tool_call(tool_name, args, result, id: id)
       end
 
       def to_contents
@@ -72,8 +72,9 @@ module Girb
       end
     end
 
-    def add_tool_call(tool_name, args, result)
+    def add_tool_call(tool_name, args, result, id: nil)
       @pending_tool_calls << {
+        id: id || "call_#{SecureRandom.hex(12)}",
         name: tool_name,
         args: args,
         result: result
@@ -105,15 +106,15 @@ module Girb
 
         # 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] }
+          result << { role: :tool_call, id: tc[:id], name: tc[:name], args: tc[:args] }
+          result << { role: :tool_result, id: tc[:id], 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] }
+        result << { role: :tool_call, id: tc[:id], name: tc[:name], args: tc[:args] }
+        result << { role: :tool_result, id: tc[:id], name: tc[:name], result: tc[:result] }
       end
 
       result

data/lib/girb/debug_context_builder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "debug_session_history"
+
+module Girb
+  class DebugContextBuilder
+    MAX_INSPECT_LENGTH = 500
+
+    def initialize(binding, thread_client: nil)
+      @binding = binding
+      @thread_client = thread_client
+    end
+
+    def build
+      {
+        source_location: capture_source_location,
+        local_variables: capture_locals,
+        instance_variables: capture_instance_variables,
+        self_info: capture_self,
+        backtrace: capture_backtrace,
+        breakpoint_info: capture_breakpoint_info,
+        session_history: capture_session_history
+      }
+    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_self
+      obj = @binding.receiver
+      {
+        class: obj.class.name,
+        inspect: safe_inspect(obj),
+        methods: obj.methods(false).first(20)
+      }
+    end
+
+    def capture_backtrace
+      return nil unless @thread_client
+
+      @thread_client.current_frame&.location&.to_s
+    rescue StandardError
+      nil
+    end
+
+    def capture_breakpoint_info
+      return nil unless defined?(DEBUGGER__) && DEBUGGER__.respond_to?(:breakpoints)
+
+      DEBUGGER__.breakpoints.map do |bp|
+        { type: bp.class.name, location: bp.to_s }
+      end
+    rescue StandardError
+      nil
+    end
+
+    def capture_session_history
+      DebugSessionHistory.format_history(20)
+    rescue StandardError
+      nil
+    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
+  end
+end