girb 0.1.2 → 0.3.0

data/lib/girb/prompt_builder.rb

@@ -2,8 +2,9 @@
 
 module Girb
   class PromptBuilder
-    SYSTEM_PROMPT = <<~PROMPT
-      You are girb, an AI assistant embedded in a Ruby developer's IRB session.
+    # Common prompt shared across all IRB modes
+    COMMON_PROMPT = <<~PROMPT
+      You are girb, an AI assistant embedded in a Ruby developer's session.
 
       ## CRITICAL: Prompt Information Takes Highest Priority
       Information in this system prompt and "User-Defined Instructions" section
@@ -14,36 +15,15 @@ module Girb
       ## Language
       Respond in the same language the user is using. Detect the user's language from their question and match it.
 
-      ## Important: Understand the IRB Session Context
-      The user is interactively executing code in IRB and asking questions within that flow.
-      "Session History" contains the code the user has executed and past AI conversations in chronological order.
-      Always interpret questions in the context of this history.
-
-      For example, if the history shows:
-        1: a = 1
-        2: b = 2
-        3: [USER] What will z be if I continue with c = 3 and beyond?
-      The user is asking about the value of z when continuing the pattern a=1, b=2, c=3... (answer: z=26).
-
-      ## Your Role
-      - Strive to understand the user's true intent and background
-        - Don't just answer the question; understand what they're trying to achieve and what challenges they face
-      - Analyze session history to understand what the user is trying to do
-      - Utilize the current execution context (variables, object state, exceptions)
-      - Provide specific, practical answers to questions
-      - Use tools to execute and verify code as needed
-
-      ## You May Ask Clarifying Questions
-      When you have doubts, ask the user about preconditions or unclear points.
-      - When multiple interpretations are possible: Confirm which interpretation is correct
-      - When preconditions are unclear: Ask what they're aiming for, what environment they're assuming
-      - When information is insufficient: Prompt for the full error message or related code
-      Asking questions increases dialogue turns but reduces misunderstandings and enables more accurate answers.
+      ## Clarifying Questions (Use Sparingly)
+      Only ask the user for clarification AFTER you have already investigated using tools.
+      - First: read the source file, check variables, run code
+      - Then: if the intent is still ambiguous after investigation, ask a focused question
 
       ## Response Guidelines
       - Keep responses concise and practical
       - Read patterns and intentions; handle hypothetical questions
-      - Code examples should use variables and objects from the current IRB context and be directly executable by pasting into IRB
+      - Code examples should use variables and objects from the current context and be directly executable
 
       ## Debugging Support on Errors
       When users encounter errors, actively support debugging.
@@ -51,11 +31,119 @@ module Girb
       - Suggest ways to inspect related code (e.g., using the inspect_object tool)
       - Guide them step-by-step toward writing more robust code
 
+      ## CRITICAL: Proactive Investigation — Act First, Don't Ask
+      You MUST investigate before asking the user for information.
+      - Use `evaluate_code` to run and verify code rather than guessing or reasoning about results.
+      - NEVER ask the user for code, file names, or variable definitions that you can look up
+        yourself with `read_file`, `evaluate_code`, `inspect_object`, or `find_file`.
+
       ## Available Tools
       Use tools to inspect variables in detail, retrieve source code, and execute code.
       Actively use the evaluate_code tool especially for verifying hypotheses and calculations.
     PROMPT
 
+    # Prompt specific to breakpoint mode (binding.girb / binding.irb)
+    BREAKPOINT_PROMPT = <<~PROMPT
+      ## Mode: Breakpoint (binding.girb)
+      You are at a BREAKPOINT in the user's Ruby script. Execution is paused at this exact line.
+
+      ### CRITICAL: Understanding Breakpoint Context
+      - Code BEFORE this line has already executed (variables are set)
+      - Code AFTER this line has NOT executed yet
+      - The user's questions about "the code", "this loop", "this method" refer to the code in the SOURCE FILE
+      - ALWAYS read the source file FIRST using `read_file` to understand what code exists
+
+      ### Your Primary Task
+      - Help the user understand, debug, or simulate the code that is ABOUT TO execute
+      - When asked to "run the code" or "execute this loop", execute the ACTUAL code from the file
+      - 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
+      - Asking the user what the code is when you can read the file
+
+      ### Debug Commands (use run_debug_command tool)
+      IRB integrates with debug gem. Use `run_debug_command` tool to execute:
+      - `next` / `n`: Step over to next line
+      - `step` / `s`: Step into method calls
+      - `continue` / `c`: Continue execution
+      - `finish`: Run until current method returns
+      - `break <file>:<line>`: Set a breakpoint
+      - `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.
+    PROMPT
+
+    # Prompt specific to interactive IRB mode (girb command)
+    INTERACTIVE_IRB_PROMPT = <<~PROMPT
+      ## Mode: Interactive IRB Session
+      The user is in an interactive IRB session, typing code and questions directly.
+
+      ### Understanding the Session
+      - "Session History" contains the code the user has executed and past AI conversations
+      - Always interpret questions in the context of this history
+      - Variables and objects from past commands are available in the current context
+
+      ### Example Context
+      If the history shows:
+        1: a = 1
+        2: b = 2
+        3: [USER] What will z be if I continue with c = 3 and beyond?
+      The user is asking about the value of z when continuing the pattern a=1, b=2, c=3... (answer: z=26).
+
+      ### Your Role
+      - Help with code exploration and experimentation
+      - Answer questions about Ruby, gems, and the current session state
+      - Assist with building and testing code interactively
+    PROMPT
+
+    # Prompt specific to Rails console mode
+    RAILS_CONSOLE_PROMPT = <<~PROMPT
+      ## Mode: Rails Console
+      The user is in a Rails console with full access to the application's models and services.
+
+      ### Rails-Specific Capabilities
+      - You can query ActiveRecord models directly
+      - Use `model_info` tool to get schema information
+      - Use `query_model` tool to execute database queries safely
+      - Access to Rails helpers, routes, and application configuration
+
+      ### Best Practices
+      - Be careful with destructive operations (update!, destroy, etc.) - warn the user
+      - Use transactions when demonstrating data modifications
+      - Suggest using `find_by` or `where` instead of `find` to avoid exceptions
+      - Remember that console changes affect the real database (unless in sandbox mode)
+    PROMPT
+
+    # Autonomous investigation prompt (shared)
+    CONTINUE_ANALYSIS_PROMPT = <<~PROMPT
+      ## Autonomous Investigation with continue_analysis
+      When you need to execute code that changes state AND then see the full updated context
+      (all local variables, instance variables, last value, etc.), use the `continue_analysis` tool.
+
+      After you call `continue_analysis`, your current response will be sent, and then you will be
+      automatically re-invoked with a refreshed context showing all current variable values.
+
+      ### When to use continue_analysis:
+      - After evaluating code that modifies variables, when you need to see the full picture
+      - When iteratively debugging: change something → check state → change more
+      - When you need to verify side effects of an operation across multiple variables
+
+      ### When NOT to use continue_analysis:
+      - When you can get the information you need with evaluate_code or inspect_object directly
+      - When you've found your answer and want to report to the user
+      - For simple one-shot investigations
+    PROMPT
+
     def initialize(question, context)
       @question = question
       @context = context
@@ -75,18 +163,20 @@ module Girb
 
     # System prompt (shared across conversation)
     def system_prompt
+      prompt = COMMON_PROMPT + "\n" + mode_specific_prompt + "\n" + CONTINUE_ANALYSIS_PROMPT
+
       custom = Girb.configuration&.custom_prompt
       if custom && !custom.empty?
-        "#{SYSTEM_PROMPT}\n\n## User-Defined Instructions\n#{custom}"
+        prompt + "\n\n## User-Defined Instructions\n#{custom}"
       else
-        SYSTEM_PROMPT
+        prompt
       end
     end
 
     # User message (context + question)
     def user_message
       <<~MSG
-        ## Current IRB Context
+        ## Current Context
         #{build_context_section}
 
         ## Question
@@ -96,29 +186,49 @@ module Girb
 
     private
 
-    def build_context_section
-      <<~CONTEXT
-        ### Session History (Previous IRB Inputs)
-        Below is the code the user has executed so far. The question is asked within this flow.
-        #{format_session_history}
+    def mode_specific_prompt
+      case detect_mode
+      when :breakpoint
+        BREAKPOINT_PROMPT
+      when :rails
+        RAILS_CONSOLE_PROMPT
+      else
+        INTERACTIVE_IRB_PROMPT
+      end
+    end
+
+    def detect_mode
+      loc = @context[:source_location]
 
-        ### Current Local Variables
-        #{format_locals}
+      # Check for breakpoint mode: source is a real file (not irb/eval)
+      if loc && loc[:file]
+        file = loc[:file].to_s
+        unless file.start_with?("(") || file.include?("irb") || file.include?("eval")
+          return :breakpoint
+        end
+      end
 
-        ### Last Evaluation Result
-        #{@context[:last_value] || "(none)"}
+      # Check for Rails mode
+      return :rails if defined?(Rails)
 
-        ### Last Exception
-        #{format_exception}
+      # Default: interactive IRB
+      :interactive
+    end
 
-        ### Methods Defined in IRB
-        #{format_method_definitions}
-      CONTEXT
+    def build_context_section
+      sections = []
+      sections << "### Source Location\n#{format_source_location}"
+      sections << "### Session History (Previous Inputs)\n#{format_session_history}"
+      sections << "### Current Local Variables\n#{format_locals}"
+      sections << "### Last Evaluation Result\n#{@context[:last_value] || "(none)"}"
+      sections << "### Last Exception\n#{format_exception}"
+      sections << "### Methods Defined in Session\n#{format_method_definitions}"
+      sections.join("\n\n")
     end
 
     def format_source_location
       loc = @context[:source_location]
-      return "(unknown)" unless loc
+      return "(interactive session)" unless loc
 
       "File: #{loc[:file]}\nLine: #{loc[:line]}"
     end

data/lib/girb/session_persistence.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Girb
+  # デバッグセッションの会話履歴を永続化するクラス
+  # 明示的にGirb.debug_sessionを設定した場合のみ保存される
+  class SessionPersistence
+    SESSIONS_DIR = ".girb/sessions"
+
+    class << self
+      attr_accessor :current_session_id
+
+      # セッションが有効か（明示的にIDが指定されているか）
+      def enabled?
+        !!Girb.debug_session
+      end
+
+      # セッションディレクトリを取得（プロジェクトルートから）
+      def sessions_dir
+        # カレントディレクトリから.girbディレクトリを探す
+        dir = Dir.pwd
+        while dir != "/"
+          girb_dir = File.join(dir, ".girb")
+          if Dir.exist?(girb_dir)
+            return File.join(girb_dir, "sessions")
+          end
+          dir = File.dirname(dir)
+        end
+
+        # 見つからなければカレントディレクトリに作成
+        File.join(Dir.pwd, SESSIONS_DIR)
+      end
+
+      # セッションファイルのパスを取得
+      def session_file_path(session_id)
+        File.join(sessions_dir, "#{session_id}.json")
+      end
+
+      # セッションを開始（既存があれば読み込み）
+      # Girb.debug_sessionが設定されている場合のみ有効
+      def start_session
+        return unless enabled?
+
+        @current_session_id = Girb.debug_session
+
+        file_path = session_file_path(@current_session_id)
+        if File.exist?(file_path)
+          load_session(file_path)
+          puts "[girb] Resumed session: #{@current_session_id}"
+        else
+          ConversationHistory.reset!
+          puts "[girb] New session: #{@current_session_id}"
+        end
+
+        @current_session_id
+      end
+
+      # セッションを保存
+      def save_session
+        return unless enabled? && @current_session_id
+
+        file_path = session_file_path(@current_session_id)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        data = {
+          session_id: @current_session_id,
+          saved_at: Time.now.iso8601,
+          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
+
+      # セッションを読み込み
+      def load_session(file_path)
+        data = JSON.parse(File.read(file_path), symbolize_names: true)
+
+        ConversationHistory.reset!
+        deserialize_messages(data[:messages])
+
+        message_count = data[:messages]&.size || 0
+        puts "[girb] Loaded #{message_count} messages from previous session"
+      rescue => e
+        puts "[girb] Failed to load session: #{e.message}"
+        ConversationHistory.reset!
+      end
+
+      # 現在のセッションをクリア（ファイルも削除）
+      def clear_session
+        if @current_session_id
+          delete_session(@current_session_id)
+          @current_session_id = nil
+        end
+        ConversationHistory.reset!
+        puts "[girb] Session cleared"
+      end
+
+      # セッション一覧を取得
+      def list_sessions
+        dir = sessions_dir
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "*.json")).map do |file|
+          data = JSON.parse(File.read(file), symbolize_names: true)
+          {
+            id: data[:session_id],
+            saved_at: data[:saved_at],
+            message_count: data[:messages]&.size || 0
+          }
+        rescue
+          nil
+        end.compact
+      end
+
+      # セッションを削除
+      def delete_session(session_id)
+        file_path = session_file_path(session_id)
+        if File.exist?(file_path)
+          File.delete(file_path)
+          puts "[girb] Session deleted: #{session_id}"
+          true
+        else
+          puts "[girb] Session not found: #{session_id}"
+          false
+        end
+      end
+
+      private
+
+      def serialize_messages
+        ConversationHistory.messages.map do |msg|
+          {
+            role: msg.role,
+            content: msg.content,
+            tool_calls: msg.tool_calls
+          }
+        end
+      end
+
+      def deserialize_messages(messages)
+        return unless messages
+
+        messages.each do |msg|
+          case msg[:role]
+          when "user"
+            ConversationHistory.add_user_message(msg[:content])
+          when "model"
+            # tool_callsがある場合は先にpending_tool_callsに追加
+            if msg[:tool_calls]&.any?
+              msg[:tool_calls].each do |tc|
+                ConversationHistory.add_tool_call(
+                  tc[:name],
+                  tc[:args],
+                  tc[:result],
+                  id: tc[:id]
+                )
+              end
+            end
+            ConversationHistory.add_assistant_message(msg[:content])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/girb/tools/continue_analysis.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class ContinueAnalysis < Base
+      class << self
+        def description
+          "Request to be re-invoked with a refreshed context (updated local variables, " \
+          "instance variables, last value, etc.). Use this after executing code that " \
+          "changes state, when you need to see the full updated picture before deciding " \
+          "your next action."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              reason: {
+                type: "string",
+                description: "Brief description of why you need a context refresh and what you plan to check next."
+              }
+            },
+            required: ["reason"]
+          }
+        end
+
+        def available?
+          # In debug mode, use run_debug_command with auto_continue instead
+          !defined?(DEBUGGER__)
+        end
+      end
+
+      def execute(binding, reason:)
+        Girb::AutoContinue.request!
+        {
+          success: true,
+          message: "You will be re-invoked with updated context after this response.",
+          reason: reason
+        }
+      end
+    end
+  end
+end

data/lib/girb/tools/debug_session_history_tool.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../debug_session_history"
+require_relative "../conversation_history"
+require_relative "../session_persistence"
+
+module Girb
+  module Tools
+    class DebugSessionHistoryTool < Base
+      class << self
+        def name
+          "get_session_history"
+        end
+
+        def description
+          "Get session history including AI conversations from previous sessions (if persisted) and current session commands. " \
+          "Use this to recall past conversations and debug commands."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              action: {
+                type: "string",
+                enum: %w[full_history list_ai_conversations],
+                description: "Action: full_history (all commands and AI conversations), list_ai_conversations (AI Q&A only)"
+              },
+              count: {
+                type: "integer",
+                description: "Number of recent entries to retrieve (default: 20)"
+              }
+            },
+            required: ["action"]
+          }
+        end
+
+        def available?
+          defined?(DEBUGGER__)
+        end
+      end
+
+      def execute(_binding, action:, count: 20)
+        case action
+        when "full_history"
+          get_full_history(count)
+        when "list_ai_conversations"
+          list_ai_conversations(count)
+        else
+          { error: "Unknown action: #{action}. Use 'full_history' or 'list_ai_conversations'." }
+        end
+      rescue StandardError => e
+        { error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def get_full_history(count)
+        result = {}
+
+        # 永続化されたセッションからの会話履歴
+        persisted = get_persisted_conversations
+        if persisted.any?
+          result[:persisted_conversations] = persisted
+        end
+
+        # 現在のセッションのデバッグ履歴
+        history = DebugSessionHistory.format_history(count)
+        if history && !history.empty?
+          result[:current_session_history] = history
+        end
+
+        if result.empty?
+          { message: "No history available" }
+        else
+          result
+        end
+      end
+
+      def list_ai_conversations(count = 20)
+        all_conversations = []
+
+        # 永続化されたセッションからの会話
+        persisted = get_persisted_conversations
+        all_conversations.concat(persisted)
+
+        # 現在のセッションの会話
+        current = DebugSessionHistory.ai_conversations.map do |c|
+          {
+            question: c.content,
+            response: c.response || "(pending)",
+            source: "current_session"
+          }
+        end
+        all_conversations.concat(current)
+
+        if all_conversations.any?
+          # 最新のcount件に制限
+          limited = all_conversations.last(count)
+          {
+            total_count: all_conversations.size,
+            showing: limited.size,
+            conversations: limited.map do |c|
+              response = c[:response] || ""
+              response_preview = response.length > 200 ? "#{response[0, 200]}..." : response
+              {
+                question: c[:question],
+                response_preview: response_preview,
+                source: c[:source] || "persisted"
+              }
+            end
+          }
+        else
+          { message: "No AI conversations in session history" }
+        end
+      end
+
+      def get_persisted_conversations
+        conversations = []
+        ConversationHistory.messages.each do |msg|
+          if msg.role == "user"
+            conversations << { question: msg.content, source: "persisted" }
+          elsif msg.role == "model" && conversations.last && !conversations.last[:response]
+            conversations.last[:response] = msg.content
+          end
+        end
+        conversations
+      end
+    end
+  end
+end

data/lib/girb/tools/evaluate_code.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "stringio"
 require_relative "base"
 
 module Girb
@@ -26,17 +27,37 @@ module Girb
       end
 
       def execute(binding, code:)
-        result = binding.eval(code)
-        {
+        captured_output = StringIO.new
+        original_stdout = $stdout
+        $stdout = captured_output
+
+        begin
+          result = binding.eval(code)
+        ensure
+          $stdout = original_stdout
+        end
+
+        stdout_str = captured_output.string
+        # Also print captured output to the real console for user visibility
+        print stdout_str unless stdout_str.empty?
+
+        response = {
           code: code,
           result: safe_inspect(result),
           result_class: result.class.name,
           success: true
         }
+        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
-        { code: code, error: "#{e.class}: #{e.message}", backtrace: e.backtrace&.first(5), success: false }
+        $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