rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/tools/runtime_info.rb

@@ -66,6 +66,10 @@ module RailsAiContext
 
           stat = ActiveRecord::Base.connection_pool.stat
           lines = [ "## Connection Pool", "" ]
+          # Read in-process, so the counts are the MCP server's own. 0 connections
+          # said nothing about an app server running beside it.
+          lines << "_This MCP server process's pool: the counts are its own connections. Each app server process keeps a pool of its own, of the size configured here._"
+          lines << ""
           lines << "| Metric | Value |"
           lines << "|--------|-------|"
           lines << "| Pool size | #{stat[:size]} |"
@@ -233,10 +237,49 @@ module RailsAiContext
           value.is_a?(Hash) ? value.map { |k, v| "#{k}: #{v}" }.join(", ") : value.to_s
         end
 
+        # Whose numbers these are depends on where the store keeps its entries.
+        def cache_scope(cache)
+          case cache.class.name.demodulize
+          when "MemoryStore"
+            "_A MemoryStore lives inside one process, so these numbers are this MCP server's own. " \
+              "Each app server process holds entries of its own that no other process sees._"
+          when "NullStore" then "_A NullStore keeps nothing, in this process or any other._"
+          when "FileStore"
+            "_The app's processes on this machine share these files#{" under `#{relative_path(cache.cache_path)}`" if cache.respond_to?(:cache_path)}._"
+          else
+            "_The app's processes in this environment share this store, so these numbers are theirs too._"
+          end
+        end
+
+        def relative_path(path)
+          path.to_s.delete_prefix("#{rails_app.root}/")
+        end
+
+        # A store no other process can read is nobody's real cache.
+        PROCESS_STORES = /\A:(memory|null)_store\b/
+
+        # This process runs one environment's store; another environment that
+        # configures a shared one (Redis, Memcached, Solid Cache) keeps the
+        # app's real cache there.
+        def configured_elsewhere
+          config = cached_context[:env_config]
+          return [] unless config.is_a?(Hash)
+
+          Array(config[:environments]).filter_map do |env|
+            next if env[:name].to_s == rails_env_name.to_s
+
+            store = (env[:notable] || {})["cache_store"]
+            next unless store && !store.match?(PROCESS_STORES)
+
+            # The store's name; its options are rails_get_env_config's to show, unshortened.
+            "- #{env[:name]}: `#{store[/\A:\w+/] || store}` (`#{env[:file]}`)"
+          end
+        end
+
         def gather_cache
           cache = Rails.cache
           lines = [ "## Cache", "" ]
-          lines << "**Store:** #{cache.class.name.demodulize}"
+          lines << "**Store:** #{cache.class.name.demodulize}, this MCP server process's `Rails.cache` (#{rails_env_name})"
 
           if cache.respond_to?(:stats)
             cache_stat_lines(cache.stats).each { |line| lines << line }
@@ -263,6 +306,13 @@ module RailsAiContext
             lines << "_Stats not available for #{cache.class.name}. Supported: Redis, MemoryStore._"
           end
 
+          lines << "" << cache_scope(cache)
+          elsewhere = configured_elsewhere
+          if elsewhere.any?
+            lines.push("", "**The app's cache in other environments:**", *elsewhere,
+                       "_`rails_get_env_config(environment:\"...\")` shows each one's options._")
+          end
+
           lines << ""
           lines
         rescue => e

data/lib/rails_ai_context/tools/safe_call.rb

@@ -27,10 +27,31 @@ module RailsAiContext
         # have its note consumed by the inner one.
         discarded = discarded_detail(kwargs)
         kwargs = listify_arrays(normalize_detail(kwargs))
-        Thread.current[:rails_ai_context_call_params] = session_params(kwargs)
+        # Before the call reads anything: an edit since the last call drops
+        # the caches and reloads the app's code (see the method).
+        RailsAiContext::Tools::BaseTool.refresh_if_files_changed!
+
+        answer = -> { answer_call(discarded) { super(**kwargs) } }
+
+        # Only the call the client made is its query. A composite tool answers
+        # by calling others, and each of those recorded itself, so one
+        # get_context read as four calls the client never made - and the
+        # first inner call took the outer one's params with it.
+        return answer.call if Thread.current[:rails_ai_context_call]
+
+        Thread.current[:rails_ai_context_call] = { tool: self, params: session_params(kwargs) }
+        begin
+          answer.call
+        ensure
+          Thread.current[:rails_ai_context_call] = nil
+        end
+      end
+
+      private
 
-        # Held across the tool body: a concurrent live reload must not unload
-        # constants while this call is reading them.
+      def answer_call(discarded)
+        # Held across the tool body: a reload another call runs must not
+        # unload constants while this call is reading them.
         #
         # The rescue sits INSIDE the block on purpose. `executor.wrap` reports
         # anything that crosses it to the host app's error_reporter as
@@ -40,18 +61,16 @@ module RailsAiContext
         RailsAiContext::CodeReloader.with_app_code do
           begin
             # One call is one run: what it reads per controller or per route is read once.
-            append_note(RailsAiContext::RunCache.around { super(**kwargs) }, invalid_detail_note(discarded))
-          rescue StandardError => e
-            # A failed call must not leak its recorded params into the next
-            # call's session entry.
-            Thread.current[:rails_ai_context_call_params] = nil
+            append_note(RailsAiContext::RunCache.around { yield }, invalid_detail_note(discarded))
+          # ScriptError too: a SyntaxError or LoadError out of an app file the
+          # tool reached must cost that call, not the stdio server and every
+          # tool with it.
+          rescue StandardError, ScriptError => e
             failure_response(e)
           end
         end
       end
 
-      private
-
       # The declared params are the contract, so a tool whose method takes
       # **kwargs refuses the same keys as one that names them.
       def unknown_params(kwargs)
@@ -93,7 +112,7 @@ module RailsAiContext
         text = +"Tool #{label} failed: #{error.class}: #{error.message.to_s.lines.first&.strip}\n"
         text << "At: #{origin}\n" unless origin.empty?
         text << "Recovery: retry with a narrower query (a single table, model, or " \
-                "controller), or run `rails-ai-context doctor` to check app health."
+                "controller), or run `#{RailsAiContext.doctor_command}` to check app health."
         MCP::Tool::Response.new([ { type: "text", text: text } ], error: true)
       end
 
@@ -107,9 +126,11 @@ module RailsAiContext
           return "(eval at #{portable_origin(eval_frame[1])})#{eval_frame[2]}"
         end
 
-        path, rest = frame.split(":", 2)
+        # FILE:LINE, split at the line number: a Windows path has a colon of
+        # its own after the drive letter (D:/a/app/x.rb:1).
+        path, rest = frame.match(/\A(.+?):(\d+(?::.*)?)\z/m)&.captures || [ frame, nil ]
         # A relative path (`(eval)`, `-e`) names nothing on this machine.
-        return frame unless File.absolute_path?(path.to_s)
+        return frame unless RailsAiContext::SafePath.absolute?(path)
 
         # This runs inside the rescue that answers a tool failure, so a raise
         # here would leave the net and reach the client as a protocol error.
@@ -124,7 +145,7 @@ module RailsAiContext
         rescue StandardError
           path
         end
-        relative = File.basename(relative) if File.absolute_path?(relative)
+        relative = File.basename(relative) if RailsAiContext::SafePath.absolute?(relative)
         [ relative, rest ].compact.join(":")
       end