girb 0.2.0 → 0.3.1

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,25 +15,6 @@ 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
-
       ## 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
@@ -41,7 +23,7 @@ module Girb
       ## 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,9 +33,6 @@ module Girb
 
       ## CRITICAL: Proactive Investigation — Act First, Don't Ask
       You MUST investigate before asking the user for information.
-      - The "Source Location" in the context tells you which file the user is working in.
-        If a Source Location is present, ALWAYS use `read_file` to read that file FIRST
-        before responding. The user's question almost certainly refers to this file's code.
       - 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`.
@@ -61,7 +40,92 @@ module Girb
       ## 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.
@@ -78,12 +142,6 @@ module Girb
       - 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
-
-      ### Example workflow:
-      1. evaluate_code("user.profile.update!(name: 'test')") → check if it succeeds
-      2. continue_analysis(reason: "Check all updated attributes after save")
-      3. [re-invoked with fresh context showing all updated locals/instance vars]
-      4. Analyze the changes and report to the user
     PROMPT
 
     def initialize(question, context)
@@ -105,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
@@ -126,32 +186,49 @@ module Girb
 
     private
 
-    def build_context_section
-      <<~CONTEXT
-        ### Source Location
-        #{format_source_location}
+    def mode_specific_prompt
+      case detect_mode
+      when :breakpoint
+        BREAKPOINT_PROMPT
+      when :rails
+        RAILS_CONSOLE_PROMPT
+      else
+        INTERACTIVE_IRB_PROMPT
+      end
+    end
 
-        ### 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 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.to_s,
+          messages: serialize_messages
+        }
+
+        File.write(file_path, JSON.pretty_generate(data))
+      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],
+                  metadata: tc[:metadata]
+                )
+              end
+            end
+            ConversationHistory.add_assistant_message(msg[:content])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/girb/tools/debug_session_history_tool.rb

@@ -2,6 +2,8 @@
 
 require_relative "base"
 require_relative "../debug_session_history"
+require_relative "../conversation_history"
+require_relative "../session_persistence"
 
 module Girb
   module Tools
@@ -12,8 +14,8 @@ module Girb
         end
 
         def description
-          "Get debug session history including debugger commands and AI conversations. " \
-          "Note: Recent history is also shown in the 'Session History' section of the context."
+          "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
@@ -44,7 +46,7 @@ module Girb
         when "full_history"
           get_full_history(count)
         when "list_ai_conversations"
-          list_ai_conversations
+          list_ai_conversations(count)
         else
           { error: "Unknown action: #{action}. Use 'full_history' or 'list_ai_conversations'." }
         end
@@ -55,34 +57,75 @@ module Girb
       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?
-          { history: history }
+          result[:current_session_history] = history
+        end
+
+        if result.empty?
+          { message: "No history available" }
         else
-          { message: "No history in this debug session" }
+          result
         end
       end
 
-      def list_ai_conversations
-        conversations = DebugSessionHistory.ai_conversations
-        if conversations.any?
+      def list_ai_conversations(count = 20)
+        all_conversations = []
+
+        # 永続化されたセッションからの会話
+        persisted = get_persisted_conversations
+        all_conversations.concat(persisted)
+
+        # 現在のセッションの会話
+        current = DebugSessionHistory.ai_conversations.map do |c|
           {
-            count: conversations.size,
-            conversations: conversations.map do |c|
-              response_preview = if c.response
-                                   c.response.length > 200 ? "#{c.response[0, 200]}..." : c.response
-                                 else
-                                   "(pending)"
-                                 end
+            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.content,
-                response_preview: response_preview
+                question: c[:question],
+                response_preview: response_preview,
+                source: c[:source] || "persisted"
               }
             end
           }
         else
-          { message: "No AI conversations in this debug session" }
+          { 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

data/lib/girb/tools/run_irb_debug_command.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Girb
+  module Tools
+    class RunIrbDebugCommand < Base
+      class << self
+        def name
+          "run_debug_command"
+        end
+
+        def description
+          "Execute a debug command in IRB. IRB integrates with debug gem, allowing step-by-step debugging. " \
+          "Use this when the user asks to step through code, set breakpoints, or navigate execution."
+        end
+
+        def parameters
+          {
+            type: "object",
+            properties: {
+              command: {
+                type: "string",
+                description: "The debug command to execute. Examples: 'next', 'step', 'continue', 'finish', " \
+                             "'break sample.rb:14', 'break sample.rb:14 if: x == 1', 'info', 'backtrace'"
+              },
+              auto_continue: {
+                type: "boolean",
+                description: "Set to true to be re-invoked after the command executes to see the new state."
+              }
+            },
+            required: ["command"]
+          }
+        end
+
+        def available?
+          # Available in IRB mode (not in active debug session)
+          # DEBUGGER__::SESSION indicates an active debug session
+          defined?(IRB) && !defined?(DEBUGGER__::SESSION)
+        end
+      end
+
+      def execute(binding, command:, auto_continue: false)
+        Girb::IrbIntegration.add_pending_irb_command(command)
+        Girb::AutoContinue.request! if auto_continue
+
+        {
+          success: true,
+          command: command,
+          auto_continue: auto_continue,
+          message: auto_continue ?
+            "Command '#{command}' will be executed. You will be re-invoked with updated context." :
+            "Command '#{command}' will be executed after this response."
+        }
+      end
+    end
+  end
+end

data/lib/girb/tools/session_history_tool.rb

@@ -2,6 +2,8 @@
 
 require_relative "base"
 require_relative "../session_history"
+require_relative "../conversation_history"
+require_relative "../session_persistence"
 
 module Girb
   module Tools
@@ -12,7 +14,8 @@ module Girb
         end
 
         def description
-          "Get IRB session history. Can retrieve specific lines, line ranges, method definitions, AI conversation details, or full history."
+          "Get IRB session history including AI conversations from previous sessions (if persisted). " \
+          "Can retrieve specific lines, line ranges, method definitions, AI conversation details, or full history."
         end
 
         def available?
@@ -151,21 +154,51 @@ module Girb
       end
 
       def list_ai_conversations
-        conversations = SessionHistory.ai_conversations
-        if conversations.any?
+        all_conversations = []
+
+        # 永続化されたセッションからの会話
+        persisted = get_persisted_conversations
+        all_conversations.concat(persisted)
+
+        # 現在のセッションの会話
+        current = SessionHistory.ai_conversations.map do |c|
           {
-            count: conversations.size,
-            conversations: conversations.map do |c|
+            line: c[:line_no],
+            question: c[:question],
+            response: c[:response] || "",
+            source: "current_session"
+          }
+        end
+        all_conversations.concat(current)
+
+        if all_conversations.any?
+          {
+            count: all_conversations.size,
+            conversations: all_conversations.map do |c|
+              response = c[:response] || ""
               {
-                line: c[:line_no],
+                line: c[:line],
                 question: c[:question],
-                response_preview: c[:response][0, 200] + (c[:response].length > 200 ? "..." : "")
+                response_preview: response.length > 200 ? "#{response[0, 200]}..." : response,
+                source: c[:source] || "persisted"
               }
             end
           }
         else
-          { message: "No AI conversations in this session" }
+          { 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
 
       def get_ai_detail(line)