girb 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fb74de93bd206f42859682f712f57bf0603c2348e665775b6c19833af65fd1f
-  data.tar.gz: af6f430afff9ca6123bddfc4a87820956cbff3fda65721d86f39f5ad688cdea5
+  metadata.gz: c2d2144162ffe9fabd66b1a4eebab7854ad593e210d3dda57714dec1ba3e4ae6
+  data.tar.gz: 81ef617d448595e2d83367ae3799680b178b7e6d2967997806715990b441972e
 SHA512:
-  metadata.gz: 8998f2942d8cf0ed23012c65dbede91b88231a0e26e31ed2b808c8cc513dc69bf162fb709320768880f59536ab5a5e1031fac0f8ac5cfdb096281d0abcae3b49
-  data.tar.gz: 1fda60427ec07042e05d2840f4ef99ba0740552e3735b10012d46c990ba62deeb653c21fc19c5653ae03e60150af9083fa3869deace3c7b3e0780632a0cbaa59
+  metadata.gz: e8e3cb78423ffe5b22af0c3bcbf94d8e12af8f2b537be73a3b53c1d68e0e30886ea06ff4ceaa49985049d5056a6858120a3e897163e7e5bd0e0ccdf3f0c1628f
+  data.tar.gz: 6cf65282ab7d1aa93097ce6e6cf7f9f9f55d113d8a34d35b44859caf48757f9dc241835de1e0f15de4933e5b17ef2d1061986cce6fed1ada15291ec3e7f70cfb

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.1] - 2026-02-07
+
+### Added
+
+- Generic `metadata` field for tool calls to support provider-specific data pass-through (e.g. Gemini 3 `thought_signature`)
+
+### 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
@@ -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/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.1"
 end

metadata

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