girb 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fb74de93bd206f42859682f712f57bf0603c2348e665775b6c19833af65fd1f
-  data.tar.gz: af6f430afff9ca6123bddfc4a87820956cbff3fda65721d86f39f5ad688cdea5
+  metadata.gz: cdae8b7956a4924603ee3edfcebdf3835ed6d994037847eed0d432d078dec400
+  data.tar.gz: 270cf95c4e39728de8cfb5ca5153139951c94b4f94d9255d250d6a47e527813e
 SHA512:
-  metadata.gz: 8998f2942d8cf0ed23012c65dbede91b88231a0e26e31ed2b808c8cc513dc69bf162fb709320768880f59536ab5a5e1031fac0f8ac5cfdb096281d0abcae3b49
-  data.tar.gz: 1fda60427ec07042e05d2840f4ef99ba0740552e3735b10012d46c990ba62deeb653c21fc19c5653ae03e60150af9083fa3869deace3c7b3e0780632a0cbaa59
+  metadata.gz: ea1a35c4aaf70ce1a4a8a28ad9a1b12fc33ef8b15e01e257ac9a94b2cbbef60d290e0d6aff426bc95b88da9257c1f0b6d76549be350bfe92bb81bd3398e349c8
+  data.tar.gz: 4c0738e997b5796c26d331c38ec60b782186c41803f1858ec1553d7a577d226ec38d3a794f1bfef008b8aa1a5c452494428d4bf55ad38b08c123fcf144e9b723

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.3.2] - 2026-02-08
+
+### Added
+
+- Show real-time progress feedback during tool execution (AI now explains each step as it works)
+- Generic `metadata` field for tool calls to support provider-specific data pass-through (e.g. Gemini 3 `thought_signature`)
+
+### Changed
+
+- Improved breakpoint tracking pattern: self-initializing `$tracked ||= []` in conditions to prevent nil errors
+
+### Fixed
+
+- Fix process crash when pressing Ctrl+C during AI API call in debug mode
+  - SIGINT now sets interrupt flag instead of propagating to main thread's `Queue.pop`
+  - Pending debug commands are properly discarded on interrupt
+  - Original SIGINT handler is always restored via `ensure` block
+- Save session history on every AI turn instead of only at exit, preventing data loss on crash or unexpected exit
+
 ## [0.3.0] - 2026-02-07
 
 ### Added

data/lib/girb/ai_client.rb

@@ -2,6 +2,7 @@
 
 require_relative "auto_continue"
 require_relative "conversation_history"
+require_relative "session_persistence"
 require_relative "providers/base"
 require_relative "debug_context_builder"
 require_relative "debug_prompt_builder"
@@ -88,6 +89,9 @@ module Girb
           Girb::AutoContinue.clear_interrupt!
         end
       end
+    ensure
+      # 毎ターン会話履歴を保存（クラッシュやexitでの消失を防止）
+      SessionPersistence.save_session
     end
 
     private
@@ -177,9 +181,9 @@ module Girb
         end
 
         if response.function_call?
-          # Accumulate text that comes with function calls
+          # Print progress text immediately (don't accumulate for re-display at the end)
           if response.text && !response.text.empty?
-            accumulated_text << response.text
+            puts response.text
           end
 
           debug_command_called = false
@@ -201,7 +205,7 @@ module Girb
               result: result
             }
 
-            ConversationHistory.add_tool_call(tool_name, tool_args, result, id: tool_id)
+            ConversationHistory.add_tool_call(tool_name, tool_args, result, id: tool_id, metadata: function_call[:metadata])
 
             if Girb.configuration.debug && result.is_a?(Hash) && result[:error]
               puts "[girb] Tool error: #{result[:error]}"

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, id: nil)
-        instance.add_tool_call(tool_name, args, result, id: id)
+      def add_tool_call(tool_name, args, result, id: nil, metadata: nil)
+        instance.add_tool_call(tool_name, args, result, id: id, metadata: metadata)
       end
 
       def to_contents
@@ -72,13 +72,14 @@ module Girb
       end
     end
 
-    def add_tool_call(tool_name, args, result, id: nil)
+    def add_tool_call(tool_name, args, result, id: nil, metadata: nil)
       @pending_tool_calls << {
         id: id || "call_#{SecureRandom.hex(12)}",
         name: tool_name,
         args: args,
-        result: result
-      }
+        result: result,
+        metadata: metadata
+      }.compact
     end
 
     def clear!
@@ -106,14 +107,18 @@ module Girb
 
         # Add tool calls and results if present
         msg.tool_calls&.each do |tc|
-          result << { role: :tool_call, id: tc[:id], name: tc[:name], args: tc[:args] }
+          tool_call = { role: :tool_call, id: tc[:id], name: tc[:name], args: tc[:args] }
+          tool_call[:metadata] = tc[:metadata] if tc[:metadata]
+          result << tool_call
           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, id: tc[:id], name: tc[:name], args: tc[:args] }
+        tool_call = { role: :tool_call, id: tc[:id], name: tc[:name], args: tc[:args] }
+        tool_call[:metadata] = tc[:metadata] if tc[:metadata]
+        result << tool_call
         result << { role: :tool_result, id: tc[:id], name: tc[:name], result: tc[:result] }
       end
 

data/lib/girb/debug_integration.rb

@@ -313,17 +313,37 @@ module Girb
         # 初回の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
         # 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

data/lib/girb/debug_prompt_builder.rb

@@ -46,15 +46,56 @@ module Girb
       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
+      **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).
 
-      This completes in 2-3 API turns instead of many turns with repeated stepping.
+      **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)
@@ -68,6 +109,11 @@ module Girb
       - "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",
       "continue", "advance to line N", "set a breakpoint"), you MUST use the `run_debug_command` tool.

data/lib/girb/prompt_builder.rb

@@ -24,6 +24,9 @@ module Girb
       - Keep responses concise and practical
       - Read patterns and intentions; handle hypothetical questions
       - Code examples should use variables and objects from the current context and be directly executable
+      - When calling tools, ALWAYS include a brief one-line comment explaining what you're about to do
+        (e.g., "ソースファイルを確認します", "ループを実行してxの値を追跡します")
+        This gives users real-time visibility into your investigation process.
 
       ## Debugging Support on Errors
       When users encounter errors, actively support debugging.
@@ -59,11 +62,6 @@ module Girb
       - When asked to track variables, run the actual code and report real results
       - NEVER invent or substitute code - always use what's in the file
 
-      ### Example: User says "run this loop and track x"
-      1. Read the source file to see the actual loop code
-      2. Execute that exact code using evaluate_code
-      3. Report the actual results
-
       ### WRONG approach:
       - Guessing what the code might do
       - Writing your own version of the code
@@ -76,11 +74,72 @@ module Girb
       - `continue` / `c`: Continue execution
       - `finish`: Run until current method returns
       - `break <file>:<line>`: Set a breakpoint
+      - `break <file>:<line> if: <condition>`: Conditional breakpoint (use `if:` with colon)
       - `backtrace` / `bt`: Show call stack
       - `info`: Show local variables
 
-      When the user asks for step-by-step execution, use `run_debug_command` with `auto_continue: true`
-      to step through the code and be re-invoked to see the results.
+      ### CRITICAL: Autonomous Debugging — Act, Don't Ask
+      When the user asks to track variables, find conditions, or debug behavior, you MUST:
+      1. Read the source file with `read_file` to understand the code
+      2. Set up tracking and breakpoints using tools
+      3. Execute — don't ask the user for file names, line numbers, or code
+
+      ### Variable Persistence Across Frames
+      Local variables created via `evaluate_code` do NOT persist after `step`, `next`, or `continue`.
+      To track values across frames, use global variables: `$tracked = []`
+
+      ### Breakpoint Line Placement Rules
+      - NEVER place a breakpoint on a block header line (`do |...|`, `.each`, `.map`, etc.) — it only hits once
+      - ALWAYS place breakpoints on a line INSIDE the block body
+      - Example:
+        ```
+        10: data.each_with_index do |val, i|   # BAD: hits only once
+        11:   x = (x * val + i * 3) % 100      # GOOD: hits every iteration
+        12: end
+        ```
+
+      ### Efficient Variable Tracking Patterns
+      **Pattern A: evaluate_code loop (PREFERRED — safe and reliable)**
+      Read the source file, reconstruct the loop, and execute it directly.
+      This always returns results even if the condition is never met.
+      ```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, final_x: x, stopped: (x == 1) }
+      RUBY
+      ```
+      IMPORTANT: Always report whether the condition was met or not.
+
+      **Pattern B: Conditional breakpoint with tracking**
+      Use ONLY when you need to interact with the actual stopped program state
+      (e.g., inspect complex objects, check call stack at the breakpoint).
+      WARNING: If the condition is never met, the program runs to completion and ALL tracked data is lost.
+      1. `run_debug_command("break file.rb:11 if: ($tracked ||= []; $tracked << x; x == 1)")` — self-initializing tracking, stop on condition
+      2. `run_debug_command("c", auto_continue: true)` — continue and be re-invoked when it stops
+      3. When re-invoked: `evaluate_code("$tracked")` — retrieve and report results
+
+      Steps 1 and 2 MUST happen in the same turn.
+
+      ### Interactive Debugging with auto_continue
+      Use `run_debug_command` with `auto_continue: true` when you need to execute a command
+      AND see the result before deciding your next action. After the command executes, you will be
+      automatically re-invoked with the updated context.
+
+      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
+
+      ### Response Guidelines
+      - When a task is complete, ALWAYS report the results — don't just execute and stop
+      - NEVER repeat the same failed action. Analyze the error and try a different approach
     PROMPT
 
     # Prompt specific to interactive IRB mode (girb command)

data/lib/girb/session_persistence.rb

@@ -66,12 +66,11 @@ module Girb
 
         data = {
           session_id: @current_session_id,
-          saved_at: Time.now.iso8601,
+          saved_at: Time.now.to_s,
           messages: serialize_messages
         }
 
         File.write(file_path, JSON.pretty_generate(data))
-        puts "[girb] Session saved: #{@current_session_id}"
       rescue => e
         puts "[girb] Failed to save session: #{e.message}"
       end
@@ -157,7 +156,8 @@ module Girb
                   tc[:name],
                   tc[:args],
                   tc[:result],
-                  id: tc[:id]
+                  id: tc[:id],
+                  metadata: tc[:metadata]
                 )
               end
             end

data/lib/girb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Girb
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: girb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - rira100000000