girb 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c8e1b470a14e892f8309060aeba93369a49d9447f5407f8f16ba114838c35ac
-  data.tar.gz: ef985221519c5ac871b158f51304aff1eef55c9ff75a34a45118842102acef84
+  metadata.gz: d2de8ea7943a9f07d92d64077d4b00698d74173b77751461b96ef0f39f450f0f
+  data.tar.gz: dc43f1e3039aa9fb5869249c93b0e17a4e501a8b5e54e3e84f99996e8be94fd1
 SHA512:
-  metadata.gz: 640764d0fad7f882743e3bf5fc973da26363e9730e65a17471c575d5e912c57b08545aaefca707dd1d87efac7fb5335d82e028718be9414c8623f29653484d44
-  data.tar.gz: 14ec81191995278196e8d8f6de2f0653456488b1139b9d1418341f56b251e2288bba8d3a8a2640e58d358ae047460e0f35169dcac9bd8c574fa20e99e10b51d4
+  metadata.gz: 0bc812210be8ee6e03a02a28972d1f1d9a9837543d02d2f9888e5b487972cbedccd173831e289b74d2e0a389f4e7ced5ce64f270278b8e2b67a06f4851bb5f57
+  data.tar.gz: 208ef2e119d7dc5da244bd016fdd8584aa2456724a91368d38d4efb206aacb2c5bace91dc23c7aa5ec002387d1f1e5272c2d4187285e0eb00d40ec44b4ad60b2

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## [0.5.0] - 2026-06-16
+
+### Added
+
+- Provider-agnostic error classification: `Providers::Base::Response` now carries an
+  `error_kind` (`:malformed_tool_call`/`:rate_limit`/`:transient`/`:timeout`/`:fatal`) with
+  `#self_correctable?` and `#transport_retryable?` predicates. Providers may set it explicitly;
+  a conservative fallback classifier infers it from the error message otherwise.
+- Restored self-correction for malformed function calls: when the provider reports a malformed
+  tool call, girb feeds corrective guidance back to the model and retries (bounded by
+  `MAX_SELF_CORRECTION`). Transport errors (rate limit, etc.) are not retried this way.
+- `LanguageDetector`: lightweight, dependency-free heuristic that locks the response language to
+  the user's original question.
+- GitHub Actions CI running the test suite on Ruby 3.2 / 3.3 / 3.4.
+
+### Changed
+
+- When the per-turn tool-call limit (`MAX_TOOL_ITERATIONS`) is reached, girb now makes one final
+  request with no tools available so the model produces a natural-language answer, instead of ending
+  silently on raw tool output.
+- The response-language directive is now derived from the original question and placed at the end
+  of the system prompt, and is propagated through auto-continue / interrupt / limit turns so English
+  system messages no longer flip the output language (root fix for the recurring "responds in
+  Japanese" / wrong-language bug).
+- `Gemfile` no longer hard-codes local provider-gem paths; a fresh clone can `bundle install` and run
+  the test suite without sibling repos (`GIRB_LOCAL_PROVIDERS=1` re-enables the local paths).
+
+### Fixed
+
+- Stop recording the assistant message twice on a non-empty text response (avoids conversation-history
+  duplication, redundant context, and language drift).
+- Tool execution no longer crashes the loop and dumps a raw backtrace when evaluated code raises a
+  `ScriptError` (e.g. `require` of an unavailable gem → `LoadError`). `evaluate_code` and the tool
+  dispatcher now catch `ScriptError` in addition to `StandardError`, returning a structured error so the
+  AI can recover. `Interrupt`/`SignalException` still propagate, so Ctrl+C handling is unaffected.
+
+### Notes / follow-ups
+
+- A user-defined `custom_prompt` is placed after the language directive, so an explicit user language
+  preference overrides automatic detection.
+- The self-correction retry records an empty assistant turn plus a user-role feedback message to keep
+  provider alternation valid. Normalizing empty turns / consecutive-user handling per provider is left
+  to the provider adapter gems (a future provider-conformance test kit will cover this).
+
 ## [0.4.2] - 2026-02-13
 
 ### Added

data/README.md

@@ -398,6 +398,23 @@ class MyProvider < Girb::Providers::Base
 end
 ```
 
+### Reporting errors
+
+On failure, return a `Response` with an `error` message. Optionally set `error_kind` to one of
+`:malformed_tool_call`, `:rate_limit`, `:transient`, `:timeout`, or `:fatal` so girb can react
+appropriately — in particular, `:malformed_tool_call` lets girb feed the model corrective guidance and
+retry automatically:
+
+```ruby
+Girb::Providers::Base::Response.new(
+  error: "the provider rejected the tool call",
+  error_kind: :malformed_tool_call
+)
+```
+
+If `error_kind` is omitted, girb infers a conservative category from the error message (defaulting to
+`:fatal`).
+
 ---
 
 ## Requirements
@@ -414,3 +431,19 @@ MIT License
 ## Contributing
 
 Bug reports and feature requests welcome at [GitHub Issues](https://github.com/rira100000000/girb/issues).
+
+### Development
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+The test suite does not require a provider gem. To run girb interactively against your local checkout
+with a provider, opt in with `GIRB_LOCAL_PROVIDERS=1` (uses a local sibling checkout such as
+`../girb-gemini` if present, otherwise the published gem):
+
+```bash
+GIRB_LOCAL_PROVIDERS=1 bundle install
+GIRB_LOCAL_PROVIDERS=1 bundle exec girb
+```

data/README_ja.md

@@ -396,6 +396,22 @@ class MyProvider < Girb::Providers::Base
 end
 ```
 
+### エラーの通知
+
+失敗時は `error` メッセージを持つ `Response` を返します。任意で `error_kind` を
+`:malformed_tool_call` / `:rate_limit` / `:transient` / `:timeout` / `:fatal` のいずれかに設定すると、
+girb が適切に対応できます。特に `:malformed_tool_call` を返すと、girb がモデルに修正指示を与えて
+自動的にリトライします:
+
+```ruby
+Girb::Providers::Base::Response.new(
+  error: "プロバイダーがツール呼び出しを拒否しました",
+  error_kind: :malformed_tool_call
+)
+```
+
+`error_kind` を省略した場合は、エラーメッセージから保守的に分類されます（既定は `:fatal`）。
+
 ---
 
 ## 動作要件
@@ -412,3 +428,19 @@ MIT License
 ## 貢献
 
 バグ報告や機能リクエストは [GitHub Issues](https://github.com/rira100000000/girb/issues) へお願いします。
+
+### 開発
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+テストの実行にプロバイダー gem は不要です。ローカルのチェックアウトをプロバイダー付きで対話的に動かす
+場合は `GIRB_LOCAL_PROVIDERS=1` を指定します（`../girb-gemini` などローカルの sibling があればそれを、
+無ければ公開 gem を使用）:
+
+```bash
+GIRB_LOCAL_PROVIDERS=1 bundle install
+GIRB_LOCAL_PROVIDERS=1 bundle exec girb
+```

data/lib/girb/ai_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "auto_continue"
+require_relative "language_detector"
 require_relative "conversation_history"
 require_relative "session_persistence"
 require_relative "providers/base"
@@ -10,6 +11,8 @@ require_relative "debug_prompt_builder"
 module Girb
   class AiClient
     MAX_TOOL_ITERATIONS = 10
+    # Max provider-agnostic retries after a malformed tool call before giving up.
+    MAX_SELF_CORRECTION = 2
 
     def initialize
       @provider = Girb.configuration.provider!
@@ -21,6 +24,10 @@ module Girb
       @irb_context = irb_context
       @debug_mode = debug_mode
       @reasoning_log = []
+      @self_correction_count = 0
+      # Lock the response language to the original question once, so English
+      # auto-continue / interrupt / limit messages can't re-anchor it.
+      @response_language = Girb::LanguageDetector.detect(question)
 
       prompt_builder = create_prompt_builder(question, context)
       @system_prompt = prompt_builder.system_prompt
@@ -98,9 +105,9 @@ module Girb
 
     def create_prompt_builder(question, context)
       if @debug_mode
-        DebugPromptBuilder.new(question, context)
+        DebugPromptBuilder.new(question, context, response_language: @response_language)
       else
-        PromptBuilder.new(question, context)
+        PromptBuilder.new(question, context, response_language: @response_language)
       end
     end
 
@@ -136,6 +143,7 @@ module Girb
         iterations += 1
         if iterations > MAX_TOOL_ITERATIONS
           puts "\n[girb] Tool iteration limit reached"
+          emit_tool_limit_summary
           break
         end
 
@@ -196,6 +204,23 @@ module Girb
 
         if response.error && !response.function_call?
           puts "[girb] API Error: #{response.error}" if Girb.configuration.debug
+
+          # Provider-agnostic self-correction: when the model emits a tool call
+          # the provider can't parse, feed it corrective guidance and retry.
+          # Bounded by MAX_SELF_CORRECTION; the outer loop's MAX_TOOL_ITERATIONS
+          # is the absolute backstop. Only malformed tool calls are retried here
+          # (transport errors like rate limits are not the model's to fix).
+          if response.self_correctable? && @self_correction_count < MAX_SELF_CORRECTION
+            @self_correction_count += 1
+            if Girb.configuration.debug
+              puts "[girb] Self-correcting malformed tool call " \
+                   "(attempt #{@self_correction_count}/#{MAX_SELF_CORRECTION})"
+            end
+            ConversationHistory.add_assistant_message("")
+            ConversationHistory.add_user_message(self_correction_feedback)
+            next
+          end
+
           ConversationHistory.add_assistant_message("")
           error_summary = response.error.to_s.split(":").first || "Unknown error"
           puts "[girb] Error: #{error_summary}"
@@ -262,7 +287,6 @@ module Girb
               puts "[girb] Warning: Empty response"
             end
           else
-            ConversationHistory.add_assistant_message(full_text)
             puts full_text
             record_ai_response(full_text)
           end
@@ -271,6 +295,53 @@ module Girb
       end
     end
 
+    # When the per-turn tool-call limit is hit, ask the model once more — with NO
+    # tools available — so it must produce a final natural-language answer instead
+    # of ending silently on raw tool output. Mirrors handle_irb_limit_reached.
+    def emit_tool_limit_summary
+      # Flush any pending tool calls into an assistant turn first, so the summary
+      # request lands AFTER the tool results in the conversation, not before.
+      # Guarded so we don't append an empty assistant turn when nothing is pending.
+      ConversationHistory.add_assistant_message("") if ConversationHistory.pending_tool_calls?
+      ConversationHistory.add_user_message(
+        "(System: Tool-call limit reached. Do NOT call any more tools. " \
+        "Summarize what you found and give your best final answer now.)"
+      )
+
+      text = ""
+      begin
+        final = @provider.chat(
+          messages: ConversationHistory.to_normalized,
+          system_prompt: @system_prompt,
+          tools: [],
+          binding: @current_binding
+        )
+        text = final&.text.to_s
+      rescue ScriptError, StandardError => e
+        # Interrupt/SignalException are not caught here, so Ctrl+C still propagates.
+        puts "[girb] Error summarizing: #{e.message}" if Girb.configuration.debug
+      end
+
+      # Always close the turn with an assistant message — even on failure/empty —
+      # so the synthetic user request above is never left dangling (which would
+      # break alternation and leak the internal instruction into the next turn).
+      ConversationHistory.add_assistant_message(text)
+
+      if text.strip.empty?
+        puts "[girb] (No final summary was produced — see the tool output above for results.)"
+      else
+        puts text
+        record_ai_response(text)
+      end
+    end
+
+    def self_correction_feedback
+      "(System: Your previous tool call could not be parsed by the provider. " \
+        "This is a Ruby environment. Respond with a single well-formed tool call " \
+        "whose arguments are valid JSON — do not use Python syntax, and do not put " \
+        "prose where structured arguments are expected.)"
+    end
+
     def execute_tool(tool_name, args)
       tool_class = Tools.find_tool(tool_name)
 
@@ -286,7 +357,11 @@ module Girb
       else
         { error: "No binding available for tool execution" }
       end
-    rescue StandardError => e
+    rescue ScriptError, StandardError => e
+      # ScriptError (LoadError/NotImplementedError) is not a StandardError; catch
+      # both so a tool can never crash the loop and dump a raw backtrace. Interrupt
+      # and SignalException are not StandardError/ScriptError, so Ctrl+C still
+      # propagates to the interrupt handling above.
       { error: "Tool execution failed: #{e.class} - #{e.message}" }
     end
 

data/lib/girb/conversation_history.rb

@@ -45,6 +45,10 @@ module Girb
       def to_normalized
         instance.to_normalized
       end
+
+      def pending_tool_calls?
+        instance.pending_tool_calls?
+      end
     end
 
     attr_reader :messages
@@ -82,6 +86,10 @@ module Girb
       }.compact
     end
 
+    def pending_tool_calls?
+      @pending_tool_calls.any?
+    end
+
     def clear!
       @messages.clear
       @pending_tool_calls.clear

data/lib/girb/debug_prompt_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "language_detector"
+
 module Girb
   class DebugPromptBuilder
     SYSTEM_PROMPT = <<~PROMPT
@@ -189,18 +191,21 @@ module Girb
       Non-navigation commands (break, info, bt) should come before navigation commands (step, next, continue).
     PROMPT
 
-    def initialize(question, context)
+    def initialize(question, context, response_language: nil)
       @question = question
       @context = context
+      @response_language = response_language || LanguageDetector.detect(question)
     end
 
     def system_prompt
+      prompt = SYSTEM_PROMPT
+      # After the bulk of the prompt (so it isn't drowned out by English debug
+      # context), but before user-defined instructions so an explicit user
+      # language preference still wins.
+      prompt += "\n" + language_directive
       custom = Girb.configuration&.custom_prompt
-      if custom && !custom.empty?
-        "#{SYSTEM_PROMPT}\n\n## User-Defined Instructions\n#{custom}"
-      else
-        SYSTEM_PROMPT
-      end
+      prompt += "\n\n## User-Defined Instructions\n#{custom}" if custom && !custom.empty?
+      prompt
     end
 
     def user_message
@@ -215,6 +220,30 @@ module Girb
 
     private
 
+    def language_directive
+      lang = @response_language
+      if lang == LanguageDetector::FALLBACK
+        <<~MSG
+          ## Response Language
+          Respond in #{lang}: detect it from the user's ORIGINAL question and match it.
+          This is NOT determined by code, tool output, logs, stack traces, system
+          messages, or prior assistant turns. Keep identifiers, code, errors, and
+          quoted output unchanged.
+          (If the user's instructions below specify a language, follow those instead.)
+        MSG
+      else
+        <<~MSG
+          ## Response Language
+          response_language for this conversation is: #{lang}.
+          It is derived ONLY from the user's original question — NOT from code, tool
+          output, logs, stack traces, system messages, or prior assistant turns.
+          Unless the user's instructions below say otherwise, your final answer
+          AND your one-line tool comments MUST be in #{lang}.
+          Keep identifiers, code, errors, and quoted output unchanged.
+        MSG
+      end
+    end
+
     def build_context_section
       <<~CONTEXT
         ### Source Location

data/lib/girb/language_detector.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Girb
+  # Lightweight, dependency-free heuristic for the response language.
+  #
+  # The goal is NOT accurate language identification — it is to stop the model
+  # from drifting to English when the user clearly wrote in Japanese (a recurring
+  # bug), without forcing a wrong language onto users of other languages.
+  #
+  # Returns one of:
+  #   "Japanese"            - high confidence (kana present)
+  #   "English"             - high confidence (Latin-only, no other scripts)
+  #   "the user's language" - uncertain; fall back to "match the user" guidance
+  module LanguageDetector
+    FALLBACK = "the user's language"
+
+    # Common English function words. Latin-only text is only called "English"
+    # when one of these appears, so Spanish/French/German/romaji questions fall
+    # back to "match the user" instead of being forced into English.
+    # Note: single-letter "i" is intentionally excluded — with the /i flag it
+    # would match a Ruby loop variable `i` and misclassify code as English.
+    ENGLISH_MARKERS = /\b(?:the|is|are|was|were|what|why|how|does|do|did|this|that|these|those|
+                          can|could|should|would|will|when|where|which|who|of|to|in|on|for|
+                          with|and|or|not|please|explain|show|tell|my|it|its)\b/xi
+
+    module_function
+
+    def detect(text)
+      s = text.to_s
+      return FALLBACK if s.strip.empty?
+
+      # Kana is unique to Japanese — any occurrence is a strong signal.
+      return "Japanese" if s.match?(/[\p{Hiragana}\p{Katakana}]/)
+
+      # Han without kana is ambiguous (could be Chinese); stay cautious.
+      return FALLBACK if s.match?(/\p{Han}/)
+
+      # Any other non-Latin script (Hangul, Cyrillic, Arabic, ...) -> don't guess.
+      return FALLBACK if s.match?(/[^\p{Latin}\p{Common}\p{Inherited}]/)
+
+      # Latin-only: only commit to English when a clear English marker is present.
+      return "English" if s.match?(ENGLISH_MARKERS)
+
+      FALLBACK
+    end
+  end
+end

data/lib/girb/prompt_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "language_detector"
+
 module Girb
   class PromptBuilder
     # Common prompt shared across all IRB modes
@@ -204,9 +206,13 @@ module Girb
       - For simple one-shot investigations
     PROMPT
 
-    def initialize(question, context)
+    def initialize(question, context, response_language: nil)
       @question = question
       @context = context
+      # Derived from the ORIGINAL user question and propagated by AiClient, so
+      # English system/continuation messages never re-anchor the output language.
+      # Falls back to detecting from this question for standalone callers.
+      @response_language = response_language || LanguageDetector.detect(question)
     end
 
     # Legacy single prompt format (for backward compatibility)
@@ -225,12 +231,17 @@ module Girb
     def system_prompt
       prompt = COMMON_PROMPT + "\n" + mode_specific_prompt + "\n" + CONTINUE_ANALYSIS_PROMPT
 
+      # Language directive goes after the bulk of the prompt so it isn't drowned
+      # out, but BEFORE user-defined instructions so an explicit user language
+      # preference still wins.
+      prompt += "\n" + language_directive
+
       custom = Girb.configuration&.custom_prompt
       if custom && !custom.empty?
-        prompt + "\n\n## User-Defined Instructions\n#{custom}"
-      else
-        prompt
+        prompt += "\n\n## User-Defined Instructions\n#{custom}"
       end
+
+      prompt
     end
 
     # User message (context + question)
@@ -246,6 +257,30 @@ module Girb
 
     private
 
+    def language_directive
+      lang = @response_language
+      if lang == LanguageDetector::FALLBACK
+        <<~MSG
+          ## Response Language
+          Respond in #{lang}: detect it from the user's ORIGINAL question and match it.
+          This is NOT determined by code, tool output, logs, stack traces, system
+          messages, or prior assistant turns. Keep identifiers, code, errors, and
+          quoted output unchanged.
+          (If the user's instructions below specify a language, follow those instead.)
+        MSG
+      else
+        <<~MSG
+          ## Response Language
+          response_language for this conversation is: #{lang}.
+          It is derived ONLY from the user's original question — NOT from code, tool
+          output, logs, stack traces, system messages, or prior assistant turns.
+          Unless the user's instructions below say otherwise, your final answer
+          AND your one-line tool comments MUST be in #{lang}.
+          Keep identifiers, code, errors, and quoted output unchanged.
+        MSG
+      end
+    end
+
     def mode_specific_prompt
       case detect_mode
       when :breakpoint

data/lib/girb/providers/base.rb

@@ -32,18 +32,70 @@ module Girb
 
       # Response object returned by chat method
       class Response
-        attr_reader :text, :function_calls, :error, :raw_response
+        # Normalized error categories. Providers SHOULD set error_kind explicitly;
+        # when omitted, a conservative fallback classification is applied.
+        #   :malformed_tool_call - the model emitted an invalid/unparseable tool call
+        #   :rate_limit          - provider rate limited the request
+        #   :transient           - temporary provider/network failure, safe to retry
+        #   :timeout             - request timed out
+        #   :fatal               - non-recoverable (auth, bad request, unknown)
+        ERROR_KINDS = %i[malformed_tool_call rate_limit transient timeout fatal].freeze
+
+        attr_reader :text, :function_calls, :error, :raw_response, :error_kind
+
+        def initialize(text: nil, function_calls: nil, error: nil, raw_response: nil, error_kind: nil)
+          if error_kind && !ERROR_KINDS.include?(error_kind)
+            raise ArgumentError, "unknown error_kind: #{error_kind.inspect} (expected one of #{ERROR_KINDS.inspect})"
+          end
 
-        def initialize(text: nil, function_calls: nil, error: nil, raw_response: nil)
           @text = text
           @function_calls = function_calls || []
           @error = error
           @raw_response = raw_response
+          @error_kind = error_kind
+          @error_kind ||= classify_error(error) if error
         end
 
         def function_call?
           @function_calls.any?
         end
+
+        # The model can fix this itself by re-emitting a valid tool call.
+        # Drives provider-agnostic self-correction in the tool loop.
+        def self_correctable?
+          @error_kind == :malformed_tool_call
+        end
+
+        # The request can be retried at the transport layer without involving
+        # the model (no conversation-history change). Not wired into the loop
+        # yet; exposed for providers and a future transport-retry milestone.
+        def transport_retryable?
+          %i[rate_limit transient timeout].include?(@error_kind)
+        end
+
+        private
+
+        # Conservative fallback used only when the provider does not set
+        # error_kind. Defaults to :fatal and classifies only a small set of
+        # unambiguous, provider-reported patterns, so a generic error message is
+        # never mistaken for a malformed tool call.
+        def classify_error(err)
+          s = err.to_s.downcase
+          return :malformed_tool_call if s.include?("malformed_function_call") || s.include?("malformed function call")
+          if s.include?("rate limit") || s.include?("rate_limit") || s.match?(/\b429\b/) ||
+             s.include?("too many requests") || s.include?("resource_exhausted") || s.include?("quota")
+            return :rate_limit
+          end
+          if s.include?("timed out") || s.include?("timeout") || s.include?("deadline exceeded") ||
+             s.include?("execution expired") || s.include?("etimedout")
+            return :timeout
+          end
+          if s.match?(/\b503\b/) || s.include?("service unavailable") || s.include?("unavailable") ||
+             s.include?("econnreset") || s.include?("connection reset")
+            return :transient
+          end
+          :fatal
+        end
       end
 
       # Normalized tool definition format

data/lib/girb/tools/evaluate_code.rb

@@ -29,18 +29,34 @@ module Girb
       def execute(binding, code:)
         captured_output = StringIO.new
         original_stdout = $stdout
-        $stdout = captured_output
+        error_response = nil
 
+        # A single ensure guarantees $stdout is restored on every exit path —
+        # including exceptions we intentionally let propagate (Interrupt,
+        # SignalException), which the rescue clauses below do NOT catch.
         begin
+          $stdout = captured_output
           result = binding.eval(code)
+        rescue SyntaxError => e
+          error_response = { code: code, error: "Syntax error: #{e.message}", success: false }
+        rescue ScriptError, StandardError => e
+          # ScriptError (LoadError/NotImplementedError) is NOT a StandardError,
+          # so without it such errors would escape and crash the tool loop.
+          error_response = { code: code, error: "#{e.class}: #{e.message}", backtrace: e.backtrace&.first(5), success: false }
         ensure
           $stdout = original_stdout
         end
 
         stdout_str = captured_output.string
         # Also print captured output to the real console for user visibility
+        # (after $stdout is restored, so it reaches the real terminal).
         print stdout_str unless stdout_str.empty?
 
+        if error_response
+          error_response[:stdout] = stdout_str unless stdout_str.empty?
+          return error_response
+        end
+
         response = {
           code: code,
           result: safe_inspect(result),
@@ -49,15 +65,6 @@ module Girb
         }
         response[:stdout] = stdout_str unless stdout_str.empty?
         response
-      rescue SyntaxError => e
-        $stdout = original_stdout if $stdout != original_stdout
-        { code: code, error: "Syntax error: #{e.message}", success: false }
-      rescue StandardError => e
-        $stdout = original_stdout if $stdout != original_stdout
-        stdout_str = captured_output&.string
-        response = { code: code, error: "#{e.class}: #{e.message}", backtrace: e.backtrace&.first(5), success: false }
-        response[:stdout] = stdout_str if stdout_str && !stdout_str.empty?
-        response
       end
     end
   end

data/lib/girb/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: girb
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - rira100000000
@@ -95,6 +95,7 @@ files:
 - lib/girb/exception_capture.rb
 - lib/girb/girbrc_loader.rb
 - lib/girb/irb_integration.rb
+- lib/girb/language_detector.rb
 - lib/girb/prompt_builder.rb
 - lib/girb/providers/base.rb
 - lib/girb/railtie.rb
@@ -138,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: AI-powered IRB assistant
 test_files: []