girb 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69a7d9cee0ae606d21d75c1fc94c1aef3665c8e38e4f704c9e8f899d7e70b943
-  data.tar.gz: 898823b1d088a67f8adb5e93705bb547d623eb0564d1831fe39cfa98757e233e
+  metadata.gz: '048b4dc3910c2afaa9bb1bd2a1f2f33f51b631b74405368daabec4cbf1ef1e2a'
+  data.tar.gz: d5b46f5c7c0f809053c8b38fd15f9af6709338c62cb2374f0a64b25f283b1807
 SHA512:
-  metadata.gz: 93e107025ea0480db5b0403531a3af424836dfbef23a7f7f174e8c89036b1b3d140571ba0334a3c2f1ff7fda89ab91df2c5478f18f945474fd1ca836eb3ae5c3
-  data.tar.gz: bd5097cc780074724642e3c2932d23178eea0140e6bdd9460489abb97a0ac3f567577d1ecd6153d29ef896ed6803ed9c1988995d64ffd47db3c08dac702f6b21
+  metadata.gz: 3e064f6e9a5dcd1ea6af090ccfc9aff2acc476fcafff772aed594ff15ecb95cfe6513e8e7facccbea490d82d691b9e495d4134fe418f8fb2d0b7bfab0e40fe25
+  data.tar.gz: 3287871b7937ea1234fdb18c6e551b96da944b12a57305b3e6c5fe5e63d2d602afa04aedc88192331176b70062ad4efc1bcfeb5c7bf3285ce603a3e090a1f005

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [0.2.0] - 2026-02-05
+
+### Added
+
+- **Debug gem (rdbg) integration**: AI assistant for step-through debugging
+  - `ai <question>` command in debugger
+  - Ctrl+Space to send input to AI
+  - Auto-routing of non-ASCII (Japanese) input to AI
+  - `run_debug_command` tool for AI to execute debugger commands (step, next, continue, break, etc.)
+- **Auto-continue for autonomous AI investigation**
+  - `continue_analysis` tool for IRB mode context refresh
+  - AI can loop through investigate-execute-analyze cycles
+  - Configurable iteration limits (MAX_ITERATIONS = 20)
+- **Ctrl+C interrupt support** for both IRB and debug modes
+  - Graceful interruption of long-running AI operations
+  - AI summarizes progress when interrupted
+- **Debug session history tracking**
+  - Track debugger commands and AI conversations
+  - `get_session_history` tool for debug mode
+- **Efficient variable tracking** with silent breakpoints
+  - `break file:line if: ($var << x; false)` pattern for recording without stopping
+
+### Changed
+
+- Separate tool sets for IRB and debug modes
+  - SHARED_TOOLS: Common tools for both modes
+  - IRB_TOOLS: SessionHistoryTool, ContinueAnalysis
+  - DEBUG_TOOLS: DebugSessionHistoryTool, RunDebugCommand
+- Improved prompts for debug mode
+  - Guidance on variable persistence across frames
+  - Instructions for efficient breakpoint usage
+  - Context-aware investigation (don't use tools for greetings)
+
+### Fixed
+
+- Tool calls now include IDs for proper conversation history
+- Auto-continue loop properly exits when debug commands are queued
+
 ## [0.1.2] - 2026-02-03
 
 ### Added
@@ -7,6 +45,7 @@
 - `.girbrc` configuration file support with directory traversal
 - Railtie for automatic Rails console integration
 - GirbrcLoader utility for finding and loading `.girbrc` files
+- `get_current_directory` tool for non-Rails environments
 
 ### Changed
 

data/README.md

@@ -10,6 +10,8 @@ An AI assistant embedded in your IRB session. It understands your runtime contex
 - **Exception Capture**: Automatically captures recent exceptions - just ask "why did this fail?" after an error
 - **Session History Understanding**: Tracks IRB input history and understands conversation flow
 - **Tool Execution**: AI autonomously executes code, inspects objects, and retrieves source code
+- **Autonomous Investigation**: AI can loop through investigate-execute-analyze cycles using `continue_analysis`
+- **Debug Gem Integration**: Use with Ruby's debug gem for step-through debugging with AI assistance
 - **Multi-language Support**: Detects user's language and responds in the same language
 - **Customizable**: Add custom prompts for project-specific instructions
 - **Provider Agnostic**: Use any LLM provider or implement your own
@@ -116,6 +118,34 @@ def problematic_method
 end
 ```
 
+### Debug with debug gem (rdbg)
+
+For step-through debugging with AI assistance, add `require "girb"` to your script:
+
+```ruby
+require "girb"
+
+def problematic_method
+  result = some_calculation
+  result
+end
+
+problematic_method
+```
+
+Then run with rdbg:
+
+```bash
+rdbg your_script.rb
+```
+
+In the debugger, use:
+- `ai <question>` - Ask AI a question
+- `Ctrl+Space` - Send current input to AI
+- Natural language (non-ASCII) input is automatically routed to AI
+
+The AI can execute debugger commands like `step`, `next`, `continue`, and set breakpoints for you.
+
 ### How to Ask AI
 
 #### Method 1: Ctrl+Space
@@ -179,6 +209,7 @@ For `girb` command, you can also configure via environment variables (used when
 | `find_file` | Search for files in the project |
 | `read_file` | Read file contents |
 | `session_history` | Get IRB session history |
+| `continue_analysis` | Request context refresh for autonomous investigation |
 
 ### Additional Tools in Rails Environment
 
@@ -187,6 +218,12 @@ For `girb` command, you can also configure via environment variables (used when
 | `query_model` | Execute queries on ActiveRecord models |
 | `model_info` | Get model schema information |
 
+### Additional Tools in Debug Mode (rdbg)
+
+| Tool | Description |
+|------|-------------|
+| `run_debug_command` | Execute debugger commands (step, next, continue, break, etc.) |
+
 ## Custom Providers
 
 Implement your own LLM provider:

data/README_ja.md

@@ -8,6 +8,8 @@ IRBセッションに組み込まれたAIアシスタント。実行中のコン
 - **例外キャプチャ**: 直前の例外を自動キャプチャ - エラー後に「なぜ失敗した？」と聞くだけでOK
 - **セッション履歴の理解**: IRBでの入力履歴を追跡し、会話の流れを理解
 - **ツール実行**: コードの実行、オブジェクトの検査、ソースコードの取得などをAIが自律的に実行
+- **自律的な調査**: `continue_analysis`を使って、調査→実行→分析のサイクルをAIが自律的にループ可能
+- **debug gem統合**: Rubyのdebug gemと連携し、AIアシスタント付きのステップ実行デバッグが可能
 - **多言語対応**: ユーザーの言語を検出し、同じ言語で応答
 - **カスタマイズ可能**: 独自のプロンプトを追加して、プロジェクト固有の指示を設定可能
 - **プロバイダー非依存**: 任意のLLMプロバイダーを使用、または独自実装が可能
@@ -114,6 +116,34 @@ def problematic_method
 end
 ```
 
+### debug gem (rdbg) でデバッグ
+
+AIアシスタント付きのステップ実行デバッグを行うには、スクリプトに `require "girb"` を追加:
+
+```ruby
+require "girb"
+
+def problematic_method
+  result = some_calculation
+  result
+end
+
+problematic_method
+```
+
+rdbgで起動:
+
+```bash
+rdbg your_script.rb
+```
+
+デバッガ内では以下の方法でAIに質問できます:
+- `ai <質問>` - AIに質問
+- `Ctrl+Space` - 入力内容をAIに送信
+- 日本語（非ASCII文字）の入力は自動的にAIにルーティング
+
+AIは `step`、`next`、`continue` などのデバッガコマンドを実行したり、ブレークポイントを設定することもできます。
+
 ### AIへの質問方法
 
 #### 方法1: Ctrl+Space
@@ -177,6 +207,7 @@ girb --help     # ヘルプを表示
 | `find_file` | プロジェクト内のファイルを検索 |
 | `read_file` | ファイルの内容を読み取り |
 | `session_history` | IRBセッションの履歴を取得 |
+| `continue_analysis` | 自律調査のためのコンテキスト更新をリクエスト |
 
 ### Rails環境での追加ツール
 
@@ -185,6 +216,12 @@ girb --help     # ヘルプを表示
 | `query_model` | ActiveRecordモデルへのクエリ実行 |
 | `model_info` | モデルのスキーマ情報を取得 |
 
+### デバッグモード (rdbg) での追加ツール
+
+| ツール | 説明 |
+|--------|------|
+| `run_debug_command` | デバッガコマンドを実行（step、next、continue、breakなど） |
+
 ## カスタムプロバイダー
 
 独自のLLMプロバイダーを実装:

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,89 @@ 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
+
+        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)
+
+            # 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)
+          Girb::AutoContinue.reset!
+          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 +112,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 +125,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 +171,46 @@ 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
+            }
 
-          # Record tool call and result in conversation history
-          ConversationHistory.add_tool_call(tool_name, tool_args, result)
+            ConversationHistory.add_tool_call(tool_name, tool_args, result, id: tool_id)
 
-          if Girb.configuration.debug && result.is_a?(Hash) && result[:error]
-            puts "[girb] Tool error: #{result[:error]}"
+            if Girb.configuration.debug && result.is_a?(Hash) && result[:error]
+              puts "[girb] Tool error: #{result[:error]}"
+            end
+
+            # In debug mode, if run_debug_command was called, we need to exit
+            # the tool loop so the debugger can execute the pending commands
+            if @debug_mode && tool_name == "run_debug_command"
+              debug_command_called = true
+            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 +251,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 +268,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 = 2
+
+    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