rails-ai-context 5.20.0 → 5.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e92439f72b8f723d75c6b62ca2fe3734f29b60548e50d2ddea836c93a66d952
-  data.tar.gz: c541d140c1f7971fa0f62d5e664673a338ffc7e809b8df8578035890224567d0
+  metadata.gz: e7cbf76ef448db45165cf06f3c2af8303b23f8629a709b20ffb61ae33093c192
+  data.tar.gz: 65fe97840d3fd23ab66b1b8e6b108914b3675e3648c51d746769d4016b6a846a
 SHA512:
-  metadata.gz: e2e550d201dd7af30d4e95e5ec368d2f376d2b8812d5254ffcf10ab8f78b1f0e089df5ba5f2664fbe858dbf2a5277c15e2489df0e86b61b22ebd44868560854f
-  data.tar.gz: 80daba010490cd5b6d1e0c4e770582b4bda8db4d073ebb9bead8d2eb3f015ec966c1ce1fef60f229755e1f1610b48b2287da480d790f20ed3be705d8b4ee95d7
+  metadata.gz: b4816a51648a6aaee1a3fd48b649ff35967e2efea2c75805da08c605a0668b8afa7dbe113b8d7f555a13c268d72f1284b69091a3b9d102465e3a6b00f5b2282b
+  data.tar.gz: cc12eaa6400a9a2906ca706b37fc92f211f0837e69038f14e6a25742be8207d529c915c4ecdb122c6bd2a20a9dc0eb86a3474cd4a65a321fa8ded9f2aa64a47d

data/CHANGELOG.md

@@ -5,6 +5,42 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.20.1] - 2026-08-11
+
+### Fixed
+
+- **`config.custom_tools` no longer takes the MCP server down.** Naming a
+  `BaseTool` subclass resolved its constant, which autoloaded the class and
+  enrolled it in the same registry the built-in list is read from, so it was
+  offered to the SDK twice and rejected as a duplicate name. The server exited
+  1 with an empty stdout while the CLI kept working. Tools are now merged by
+  name; two different classes claiming one name keep the built-in and warn.
+- **`--flag value` no longer inverts boolean parameters.** A boolean flag
+  consumed no value, so `--app-only false` set `app_only` to true and dropped
+  the `false` without a warning. Affected every boolean on every tool, and
+  `--param value` is the form the CLI docs teach.
+- **The static tier stops answering questions it cannot answer.** `mailers`
+  reported "no mailers found" for an app with mailers, `engines` reported no
+  engines loaded, `i18n` reported one locale while listing two locale files,
+  and the Action Cable channels, deprecators, on_load hooks, cache store and
+  credentials sections vanished with no marker. Mailers, channels and locales
+  are read from source through `static_call`; the rest report
+  `[UNAVAILABLE]`. Locale files using YAML anchors are read correctly, and an
+  `I18n.default_locale` set in an initializer is honoured.
+- **`app_only:false` lists the routes it counts.** It announced the unfiltered
+  total above a body containing only app routes, and never showed a framework
+  route. App routes are now listed first, so they cannot paginate out of sight.
+  `app_only:true` says how many routes it hid and how to see them.
+- **One app, one route count.** Generated context files counted raw routes
+  while the tools merged each resource's `PATCH`/`PUT` pair, so `CLAUDE.md` and
+  `rails_get_routes` quoted different numbers for the same app. The totals are
+  merged at the source, and the serializers read
+  `config.excluded_route_prefixes` instead of a hardcoded copy.
+- **`rails_get_gems` past the last page** no longer opens with "No notable gems
+  found" above its own "No items at offset N" note.
+- The MCP startup banner reads the list off the built server, so it cannot
+  announce a different set of tools than the server answers with.
+
 ## [5.20.0] - 2026-08-11
 
 ### Security

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -15,6 +15,13 @@ module RailsAiContext
       class ToolNotFoundError < StandardError; end
       class InvalidArgumentError < StandardError; end
 
+      # The only words that read as true, and every word a boolean flag will
+      # consume as its value. Kept together so the two cannot drift: a word
+      # accepted here but missing from TRUTHY would silently mean false.
+      TRUTHY_WORDS = %w[true 1 yes].freeze
+      FALSEY_WORDS = %w[false 0 no].freeze
+      BOOLEAN_WORDS = (TRUTHY_WORDS + FALSEY_WORDS).freeze
+
       attr_reader :tool_class, :raw_args, :json_mode, :error
 
       def initialize(tool_name, raw_args, json_mode: false)
@@ -210,8 +217,18 @@ module RailsAiContext
               prop = properties[key] || {}
 
               if prop[:type] == "boolean"
-                result[key] = true
-                i += 1
+                # `--flag false` is the form docs/CLI.md teaches for every
+                # other param, so a boolean has to honour it too. Only an
+                # explicit boolean word is consumed - anything else stays a
+                # separate argument and the flag means true.
+                nxt = args[i + 1]
+                if nxt && BOOLEAN_WORDS.include?(nxt.downcase)
+                  result[key] = coerce_value(nxt, prop)
+                  i += 2
+                else
+                  result[key] = true
+                  i += 1
+                end
                 next
               end
 
@@ -247,7 +264,7 @@ module RailsAiContext
         when "integer"
           raw.to_i
         when "boolean"
-          %w[true 1 yes].include?(raw.to_s.downcase)
+          TRUTHY_WORDS.include?(raw.to_s.downcase)
         when "array"
           raw.is_a?(Array) ? raw : raw.to_s.split(",").map(&:strip)
         else

data/lib/rails_ai_context/introspector.rb

@@ -122,9 +122,7 @@ module RailsAiContext
     end
 
     def unavailable_reason
-      reason = RailsAiContext.static_reason
-      base = "requires a booted Rails app"
-      reason ? "#{base} (#{reason})" : base
+      Introspectors::StaticTier.unavailable_reason
     end
 
     def rails_version

data/lib/rails_ai_context/introspectors/active_support_introspector.rb

@@ -8,7 +8,7 @@ module RailsAiContext
     # Covers RAILS_NERVOUS_SYSTEM.md §17 (ActiveSupport).
     class ActiveSupportIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -30,6 +30,25 @@ module RailsAiContext
         { error: e.message }
       end
 
+      # Concerns, MessageVerifier usage and tagged logging are read off disk.
+      # The registered deprecators, the subscribed load hooks and the cache
+      # store only exist in a running process; an empty list for them renders
+      # as "this app has none", so they refuse instead.
+      def static_call
+        unavailable = { unavailable: StaticTier.unavailable_reason }
+        {
+          concerns: extract_concerns,
+          deprecators: unavailable,
+          message_verifier_usage: extract_message_verifier_usage,
+          tagged_logging: detect_tagged_logging,
+          on_load_hooks: unavailable,
+          cache_usage: unavailable
+        }
+      rescue => e
+        $stderr.puts "[rails-ai-context] ActiveSupportIntrospector#static_call failed: #{e.message}" if ENV["DEBUG"]
+        { error: e.message }
+      end
+
       private
 
       def root

data/lib/rails_ai_context/introspectors/engine_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # Identifies well-known engines and provides context about what each does.
     class EngineIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -50,6 +50,20 @@ module RailsAiContext
         { error: e.message }
       end
 
+      # config/routes.rb is a file, so mounts read the same either way. Which
+      # engine classes a process loaded is only knowable from that process -
+      # and testing `defined?(Rails::Engine)` instead of the tier answered from
+      # the half-finished boot that put us here, which is the common way into
+      # the static tier.
+      def static_call
+        {
+          mounted_engines: discover_mounted_engines,
+          rails_engines: { unavailable: StaticTier.unavailable_reason }
+        }
+      rescue => e
+        { error: e.message }
+      end
+
       private
 
       def root

data/lib/rails_ai_context/introspectors/i18n_introspector.rb

@@ -7,7 +7,12 @@ module RailsAiContext
     # Discovers internationalization setup: locales, backends, key counts.
     class I18nIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
+
+      # Both spellings apps use: `config.i18n.default_locale = :es` in
+      # application.rb or an environment file, and a bare
+      # `I18n.default_locale = :es` in an initializer.
+      DEFAULT_LOCALE_ASSIGNMENT = /(?:config\.i18n|I18n)\.default_locale\s*=\s*[:"']([\w-]+)/
 
       attr_reader :app
 
@@ -30,8 +35,65 @@ module RailsAiContext
         { error: e.message }
       end
 
+      # The locale files are the same files either way; only the list of
+      # locales and the default came from a running I18n. Read both from disk
+      # rather than report the library's own defaults as the app's.
+      def static_call
+        locales = locales_from_files
+        default = default_locale_from_config
+
+        {
+          default_locale: default,
+          available_locales: locales,
+          backend: nil,
+          locale_files: extract_locale_files,
+          total_locale_files: count_locale_files,
+          locale_coverage: detect_locale_coverage(locales: locales.map(&:to_sym), default: default.to_sym)
+        }.merge(detect_fallback_config)
+      rescue => e
+        { error: e.message }
+      end
+
       private
 
+      # Every top-level key across config/locales - the same population Rails
+      # builds available_locales from.
+      def locales_from_files
+        dir = File.join(root, "config/locales")
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**/*.{yml,yaml}")).flat_map do |path|
+          content = RailsAiContext::SafeFile.read(path)
+          next [] unless content
+
+          # aliases: true, like extract_locale_files. Sharing formats through a
+          # YAML anchor is ordinary, and without the flag Psych raises, the
+          # rescue swallows it, and every locale in that file disappears while
+          # the Locale Files section still lists it.
+          data = YAML.safe_load(content, permitted_classes: [ Symbol ], aliases: true)
+          data.is_a?(Hash) ? data.keys.map(&:to_s) : []
+        rescue StandardError
+          []
+        end.uniq.sort
+      end
+
+      # Rails' own default is :en, so "en" is the right answer when the app
+      # never says otherwise - not a guess.
+      def default_locale_from_config
+        candidates = [ File.join(root, "config", "application.rb") ] +
+                     Dir.glob(File.join(root, "config", "environments", "*.rb")) +
+                     Dir.glob(File.join(root, "config", "initializers", "*.rb"))
+
+        candidates.each do |path|
+          next unless File.exist?(path)
+
+          content = RailsAiContext::SafeFile.read(path)
+          match = content&.match(DEFAULT_LOCALE_ASSIGNMENT)
+          return match[1] if match
+        end
+        "en"
+      end
+
       def root
         app.root.to_s
       end
@@ -77,8 +139,7 @@ module RailsAiContext
         {}
       end
 
-      def detect_locale_coverage
-        locales = I18n.available_locales
+      def detect_locale_coverage(locales: I18n.available_locales, default: I18n.default_locale)
         return {} if locales.size < 2
 
         # Coverage is the share of the default locale's keys that the other
@@ -86,8 +147,8 @@ module RailsAiContext
         # for a locale that translates few default keys but adds many of its
         # own - the one number a translator must not be told is fine.
         coverage = {}
-        default_keys = key_paths_for_locale(I18n.default_locale)
-        locales.reject { |l| l == I18n.default_locale }.each do |locale|
+        default_keys = key_paths_for_locale(default)
+        locales.reject { |l| l == default }.each do |locale|
           locale_keys = key_paths_for_locale(locale)
           translated = (default_keys & locale_keys).size
           coverage[locale.to_s] = {
@@ -110,7 +171,7 @@ module RailsAiContext
         find_locale_paths(locale).flat_map do |path|
           content = RailsAiContext::SafeFile.read(path)
           next [] unless content
-          data = YAML.safe_load(content, permitted_classes: [ Symbol ])
+          data = YAML.safe_load(content, permitted_classes: [ Symbol ], aliases: true)
           next [] unless data.is_a?(Hash)
 
           # A locale root may be written `en:` or `:en:` - both load, and both

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # and Action Cable channels.
     class JobIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
 
       CHANNEL_MACROS = %i[identified_by stream_from stream_for periodically].freeze
 
@@ -31,6 +31,19 @@ module RailsAiContext
         }
       end
 
+      # Mailers and channels are ordinary classes in ordinary directories, so
+      # the answer is the same with or without a booted app. Only the way in
+      # differs: descendants when Rails is up, the AST when it is not.
+      def static_call
+        {
+          jobs: extract_jobs_from_source,
+          mailers: extract_mailers_from_source,
+          channels: extract_channels_from_source,
+          recurring_jobs: extract_solid_queue_recurring,
+          sidekiq_config: extract_sidekiq_config
+        }
+      end
+
       private
 
       def extract_jobs
@@ -235,6 +248,63 @@ module RailsAiContext
         []
       end
 
+      # A mailer's actions are its public instance methods, which is exactly
+      # what `instance_methods(false)` reports on the booted side.
+      def extract_mailers_from_source
+        source_classes(File.join(app.root, "app", "mailers")).filter_map do |name, methods|
+          next if name == "ApplicationMailer"
+
+          actions = methods.select { |m| m[:scope] == :instance && m[:visibility] == :public }
+                           .map { |m| m[:name] }.sort
+          next if actions.empty?
+
+          { name: name, actions: actions, confidence: RailsAiContext::Confidence::STATIC }
+        end.sort_by { |m| m[:name] }
+      end
+
+      def extract_channels_from_source
+        # ApplicationCable holds the base Channel and Connection, neither of
+        # which is a channel of the app's own.
+        source_classes(File.join(app.root, "app", "channels")).filter_map do |name, methods|
+          next if name.start_with?("ApplicationCable::")
+
+          stream_methods = methods.select { |m| m[:scope] == :instance }
+                                  .map { |m| m[:name] }
+                                  .select { |m| m.start_with?("stream_") || m == "subscribed" }
+          { name: name, stream_methods: stream_methods, confidence: RailsAiContext::Confidence::STATIC }
+        end.sort_by { |c| c[:name] }
+      end
+
+      # Class name plus method list for every .rb under `dir`, read from the
+      # AST. Yields nothing when the directory is absent.
+      #
+      # The name comes from the path, not the AST: Zeitwerk requires the two to
+      # agree, and only the path carries the namespace. Reading `class Channel`
+      # out of `application_cable/channel.rb` yields "Channel", which matches
+      # no base-class filter and no name the booted app would report.
+      def source_classes(dir)
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**/*.rb")).sort.filter_map do |path|
+          next unless File.exist?(path) && File.size(path) > 0
+          next if File.size(path) > RailsAiContext.configuration.max_file_size
+          # Rails adds app/*/concerns as its own autoload root, so what lives
+          # there is a mixin, not a mailer or a channel - and naming it from
+          # the path would invent a `Concerns::` namespace that never exists.
+          next if path.sub("#{dir}/", "").start_with?("concerns/")
+
+          walked = SourceIntrospector.walk(path, { methods: Listeners::MethodsListener })
+          [ constant_name_for(path, dir), walked[:methods] || [] ]
+        rescue StandardError, ScriptError => e
+          $stderr.puts "[rails-ai-context] source_classes failed for #{path}: #{e.message}" if ENV["DEBUG"]
+          nil
+        end
+      end
+
+      def constant_name_for(path, dir)
+        path.sub("#{dir}/", "").sub(/\.rb\z/, "").camelize
+      end
+
       def extract_channels
         return [] unless defined?(ActionCable::Channel::Base)
 

data/lib/rails_ai_context/introspectors/route_introspector.rb

@@ -20,7 +20,11 @@ module RailsAiContext
         root = routes.find { |r| r[:path] == "/" && r[:verb]&.include?("GET") }
 
         {
-          total_routes: routes.size,
+          # Merged, because that is how every surface that lists routes counts
+          # them: Rails registers PATCH and PUT separately for one update
+          # action, and a raw total here left the generated context files
+          # quoting a grand total their own app-route number cannot reach.
+          total_routes: Tools::BaseTool.dedupe_put_patch_routes(routes).size,
           by_controller: group_by_controller(routes),
           api_namespaces: detect_api_namespaces(routes),
           mounted_engines: detect_mounted_engines,

data/lib/rails_ai_context/introspectors/static_tier.rb

@@ -18,6 +18,15 @@ module RailsAiContext
 
       KINDS = [ FILES_ONLY, RUNTIME_ONLY, ALTERNATE_SOURCE ].freeze
 
+      # One wording for "the app did not boot", carrying whatever the boot
+      # failure said. Forked copies drift, and a single run then emits two
+      # different explanations for the same condition.
+      def self.unavailable_reason
+        reason = RailsAiContext.static_reason
+        base = "requires a booted Rails app"
+        reason ? "#{base} (#{reason})" : base
+      end
+
       def static_tier(kind = nil)
         return declared_static_tier if kind.nil?
 

data/lib/rails_ai_context/serializers/compact_serializer_helper.rb

@@ -36,13 +36,14 @@ module RailsAiContext
 
         routes = context[:routes]
         if routes && !routes[:error]
-          internal = %w[action_mailbox/ active_storage/ rails/ conductor/ devise/ turbo/]
+          # From config, like rails_get_routes and rails_onboard. Hardcoding it
+          # here made one documented option enough to reopen the count drift.
+          internal = RailsAiContext.configuration.excluded_route_prefixes
           by_controller = routes[:by_controller] || {}
           app_ctrls = by_controller.keys.reject { |k| internal.any? { |p| k.downcase.start_with?(p) } }
-          # Numerator and denominator must describe the same population: app
-          # routes across app controllers, with the grand total (framework
-          # routes included) alongside for scale.
-          app_routes = app_ctrls.sum { |k| Array(by_controller[k]).size }
+          # Deduped, so this number, the grand total beside it, and
+          # rails_get_routes' header all describe the same population.
+          app_routes = app_ctrls.sum { |k| Tools::BaseTool.dedupe_put_patch_routes(Array(by_controller[k])).size }
           lines << "- Routes: #{count_phrase(app_routes, "app route")} across " \
                    "#{count_phrase(app_ctrls.size, "controller")} " \
                    "(#{routes[:total_routes]} total incl. framework)"

data/lib/rails_ai_context/serializers/copilot_serializer.rb

@@ -39,10 +39,12 @@ module RailsAiContext
         if routes && !routes[:error]
           # Same population as the compact serializers: app routes across app
           # controllers, so every generated context file quotes one number.
-          internal = %w[action_mailbox/ active_storage/ rails/ conductor/ devise/ turbo/]
+          # From config, like rails_get_routes and rails_onboard. Hardcoding it
+          # here made one documented option enough to reopen the count drift.
+          internal = RailsAiContext.configuration.excluded_route_prefixes
           by_controller = routes[:by_controller] || {}
           app_ctrls = by_controller.keys.reject { |k| internal.any? { |p| k.downcase.start_with?(p) } }
-          app_routes = app_ctrls.sum { |k| Array(by_controller[k]).size }
+          app_routes = app_ctrls.sum { |k| Tools::BaseTool.dedupe_put_patch_routes(Array(by_controller[k])).size }
           lines << "- Routes: #{count_phrase(app_routes, "app route")} across " \
                    "#{count_phrase(app_ctrls.size, "controller")} " \
                    "(#{routes[:total_routes]} total incl. framework)"

data/lib/rails_ai_context/server.rb

@@ -112,7 +112,7 @@ module RailsAiContext
         name: config.server_name,
         version: config.server_version,
         instructions: "Ground truth engine for Rails apps. Live Prism AST introspection. Zero stale data.",
-        tools: active_tools(config) + validated_custom_tools,
+        tools: merge_tools(active_tools(config), validated_custom_tools),
         resource_templates: Resources.resource_templates,
         configuration: mcp_config
       )
@@ -146,12 +146,53 @@ module RailsAiContext
       tools.reject { |t| skip.include?(t.tool_name) }
     end
 
+    # The MCP SDK refuses a tool list with a repeated name, so one duplicate
+    # takes the whole server down. Two ways they arise:
+    #
+    #   - The same class twice. Naming a BaseTool subclass in custom_tools
+    #     resolves its constant, which autoloads the file, which fires
+    #     `inherited` and enrols it in the registry active_tools reads.
+    #   - Two different classes claiming one name. Deliberate replacement is
+    #     spelled with skip_tools; without it, keep the built-in and say so.
+    def merge_tools(builtin, custom)
+      merged = (builtin + custom).uniq
+      builtin_names = builtin.to_set { |t| tool_label(t) }
+
+      merged.group_by { |t| tool_label(t) }.flat_map do |name, tools|
+        next tools if tools.size == 1
+
+        # Only skip_tools can settle a clash with a built-in; when both
+        # claimants are custom there is no built-in to skip, and saying so
+        # would send the user after a setting that cannot help.
+        advice = if builtin_names.include?(name)
+          "keeping the built-in. Add #{name.inspect} to config.skip_tools to replace it."
+        else
+          "keeping the first. Give one of them a different tool_name."
+        end
+        $stderr.puts "[rails-ai-context] WARNING: #{tools.size} tools claim the name #{name.inspect}; #{advice}"
+        [ tools.first ]
+      end
+    end
+
+    # MCP::Tool subclasses answer tool_name; anything else falls back to the
+    # class name, which is what the SDK would key on anyway.
+    def tool_label(tool)
+      tool.respond_to?(:tool_name) ? tool.tool_name : tool.name
+    end
+
+    # Read the list off the server rather than rebuilding it. Recomputing it
+    # from the registry drops any custom tool that is not a BaseTool, so the
+    # banner announced a different set than the server answered with.
+    def tool_banner(server)
+      names = server.tools.values.map { |t| tool_label(t) }.sort
+      "[rails-ai-context] Tools (#{names.size}): #{names.join(', ')}"
+    end
+
     def start_stdio(server)
       transport = MCP::Server::Transports::StdioTransport.new(server)
-      tools = active_tools(RailsAiContext.configuration)
       # Log to stderr so we don't pollute the JSON-RPC channel on stdout
       $stderr.puts "[rails-ai-context] MCP server started (stdio transport)"
-      $stderr.puts "[rails-ai-context] Tools (#{tools.size}): #{tools.map { |t| t.tool_name }.join(', ')}"
+      $stderr.puts tool_banner(server)
       maybe_start_live_reload(server)
       transport.open
     end
@@ -169,9 +210,8 @@ module RailsAiContext
                      "this exposes all tools to the network without authentication. " \
                      "Use 127.0.0.1 (default) unless you have external auth in place."
       end
-      tools = active_tools(config)
       $stderr.puts "[rails-ai-context] MCP server starting on #{config.http_bind}:#{config.http_port}#{config.http_path}"
-      $stderr.puts "[rails-ai-context] Tools (#{tools.size}): #{tools.map { |t| t.tool_name }.join(', ')}"
+      $stderr.puts tool_banner(server)
       maybe_start_live_reload(server)
 
       begin

data/lib/rails_ai_context/tools/get_active_support.rb

@@ -57,7 +57,19 @@ module RailsAiContext
           end
         end
 
+        # A section the introspector could not reach says so under its own
+        # heading. Silently omitting it reads as "nothing here".
+        def render_unavailable(lines, title, data)
+          return false unless data.is_a?(Hash) && data[:unavailable]
+
+          lines << "" << "## #{title}"
+          lines << RailsAiContext::Confidence.unavailable(data[:unavailable])
+          true
+        end
+
         def render_simple_list(lines, title, items)
+          return if render_unavailable(lines, title, items)
+
           items = Array(items)
           return if items.empty?
 
@@ -88,6 +100,8 @@ module RailsAiContext
         end
 
         def render_on_load_hooks(lines, hooks)
+          return if render_unavailable(lines, "Subscribed on_load Hooks", hooks)
+
           hooks = Array(hooks)
           return if hooks.empty?
 
@@ -96,6 +110,8 @@ module RailsAiContext
         end
 
         def render_cache(lines, cache)
+          return if render_unavailable(lines, "Cache Store", cache)
+
           cache = cache || {}
           return if cache.empty? || cache[:store].to_s.empty?
 

data/lib/rails_ai_context/tools/get_engines.rb

@@ -37,7 +37,9 @@ module RailsAiContext
           end
 
           lines << "" << "## Loaded Engine Classes"
-          if loaded.any?
+          if loaded.is_a?(Hash) && loaded[:unavailable]
+            lines << RailsAiContext::Confidence.unavailable(loaded[:unavailable])
+          elsif loaded.any?
             loaded.each do |e|
               parts = []
               parts << count_phrase(e[:route_count], "route") if e[:route_count]

data/lib/rails_ai_context/tools/get_env.rb

@@ -128,6 +128,10 @@ module RailsAiContext
           lines << "## Credentials Keys (values hidden)"
           credentials_keys.each { |k| lines << "- `#{k}`" }
           lines << ""
+        elsif credentials_file_present?
+          lines << "## Credentials Keys (values hidden)"
+          lines << RailsAiContext::Confidence.unavailable("credentials are encrypted; reading the key names needs a booted app with its master key")
+          lines << ""
         end
 
         # Encrypted columns
@@ -228,6 +232,10 @@ module RailsAiContext
           lines << "## Credentials Keys (values hidden)"
           credentials_keys.each { |k| lines << "- `#{k}`" }
           lines << ""
+        elsif credentials_file_present?
+          lines << "## Credentials Keys (values hidden)"
+          lines << RailsAiContext::Confidence.unavailable("credentials are encrypted; reading the key names needs a booted app with its master key")
+          lines << ""
         end
 
         # Encrypted columns
@@ -500,6 +508,18 @@ module RailsAiContext
         []
       end
 
+      # An encrypted credentials file the tool could not open is a different
+      # fact from an app with no credentials, and only one of them is true here.
+      private_class_method def self.credentials_file_present?
+        root = rails_app.root.to_s
+        # Rails 6+ apps commonly carry only per-environment credentials, with
+        # no top-level file at all.
+        File.exist?(File.join(root, "config", "credentials.yml.enc")) ||
+          Dir.glob(File.join(root, "config", "credentials", "*.yml.enc")).any?
+      rescue StandardError
+        false
+      end
+
       private_class_method def self.detect_credentials_keys
         keys = []
 

data/lib/rails_ai_context/tools/get_gems.rb

@@ -81,11 +81,14 @@ module RailsAiContext
               line += " _(config: #{config_hint})_" if config_hint
               lines << line
             end
-          else
+          elsif page[:total].zero?
             all_cats = (gems[:notable_gems] || []).map { |g| g[:category] }.uniq.sort
             hint = all_cats.any? ? " Available categories: #{all_cats.join(', ')}" : ""
             lines << "_No notable gems found#{" in category '#{category}'" unless category == 'all'}.#{hint}_"
           end
+          # An empty page past the end is not an empty app. Saying "no notable
+          # gems found" above "No items at offset 9999. Total: 13." contradicts
+          # itself, and the first line is the one that reads as the answer.
 
           lines << "" << page[:hint] unless page[:hint].empty?
           text_response(lines.join("\n"))

data/lib/rails_ai_context/tools/get_i18n.rb

@@ -58,7 +58,9 @@ module RailsAiContext
           lines = [ "# I18n" ]
           lines << ""
           lines << "- **Default locale:** #{i18n[:default_locale]}"
-          lines << "- **Backend:** #{i18n[:backend]}"
+          # The backend class is a runtime fact. Printing the I18n gem's own
+          # default when no app booted states it as the app's choice.
+          lines << "- **Backend:** #{i18n[:backend]}" if i18n[:backend]
           lines << "- **Available locales:** #{available_list(i18n)}"
           lines << "- **Locale files:** #{i18n[:total_locale_files] || files.size}"
 

data/lib/rails_ai_context/tools/get_mailers.rb

@@ -52,7 +52,8 @@ module RailsAiContext
           if page[:items].any?
             page[:items].each do |m|
               lines << "" << "## #{m[:name]}"
-              lines << "- **Delivery method:** #{m[:delivery_method]}"
+              # Configured at boot, so the static tier has no value to give.
+              lines << "- **Delivery method:** #{m[:delivery_method]}" if m[:delivery_method].present?
               lines << "- **Actions:** #{Array(m[:actions]).join(', ')}"
             end
           else

data/lib/rails_ai_context/tools/get_routes.rb

@@ -34,6 +34,10 @@ module RailsAiContext
         }
       )
 
+      def self.framework_controller?(name)
+        route_prefixes.any? { |p| name.downcase.start_with?(p) }
+      end
+
       def self.route_prefixes
         RailsAiContext.configuration.excluded_route_prefixes
       end
@@ -61,9 +65,9 @@ module RailsAiContext
           # were dropped so headers can say the count is app-only, not the total.
           excluded_framework_count = 0
           if app_only
-            framework_ctrls = by_controller.select { |k, _| route_prefixes.any? { |p| k.downcase.start_with?(p) } }
+            framework_ctrls = by_controller.select { |k, _| framework_controller?(k) }
             excluded_framework_count = framework_ctrls.values.sum { |actions| dedupe_put_patch_routes(actions).size }
-            by_controller = by_controller.reject { |k, _| route_prefixes.any? { |p| k.downcase.start_with?(p) } }
+            by_controller = by_controller.reject { |k, _| framework_controller?(k) }
           end
 
           # Filter by controller - accepts "posts", "PostsController", "posts_controller", "Api::V1::Posts"
@@ -133,11 +137,17 @@ module RailsAiContext
             text_response(lines.join("\n"))
 
           when "standard"
-            # Flatten all routes into a tagged array, then paginate
-            app_routes = controller ? by_controller : by_controller.reject { |k, _| route_prefixes.any? { |p| k.downcase.start_with?(p) } }
-            framework_routes = controller ? {} : by_controller.select { |k, _| route_prefixes.any? { |p| k.downcase.start_with?(p) } }
-
-            flat_routes = app_routes.sort.flat_map { |ctrl, actions| actions.map { |r| r.merge(_ctrl: ctrl) } }
+            # List whatever survived the app_only filter. Re-splitting here
+            # dropped the framework routes from the body while the header kept
+            # counting them, so `app_only:false` announced 50 routes and showed
+            # 24 of them.
+            #
+            # App controllers first: sorted plainly, `action_mailbox/` and
+            # `active_storage/` lead the alphabet, so on an app with more
+            # framework routes than the page limit the app's own would
+            # paginate out of sight.
+            ordered = by_controller.sort_by { |ctrl, _| [ framework_controller?(ctrl) ? 1 : 0, ctrl ] }
+            flat_routes = ordered.flat_map { |ctrl, actions| actions.map { |r| r.merge(_ctrl: ctrl) } }
             page = paginate(flat_routes, offset: offset, limit: limit, default_limit: 150)
 
             lines = [ "# Routes (#{count_label})", "" ]
@@ -172,10 +182,9 @@ module RailsAiContext
               lines << "- `#{r[:verb]}` `#{r[:path]}` → #{r[:action]}#{helper_part}#{params_part}"
             end
 
-            if framework_routes.any?
-              total_fw = framework_routes.values.sum(&:size)
-              fw_names = framework_routes.keys.map { |k| k.split("/").first }.uniq.join(", ")
-              lines << "" << "_#{fw_names} framework routes: #{total_fw} total (use `controller:\"devise/sessions\"` to see details)_"
+            if excluded_framework_count > 0 && controller.nil?
+              lines << "" << "_#{count_phrase(excluded_framework_count, "framework route")} hidden. " \
+                             "Use `app_only:false` to include them._"
             end
 
             lines << "" << page[:hint] unless page[:hint].empty?

data/lib/rails_ai_context/tools/section_fetch.rb

@@ -72,9 +72,7 @@ module RailsAiContext
       end
 
       def unavailable_static_reason
-        reason = RailsAiContext.static_reason
-        base = "requires a booted Rails app"
-        reason ? "#{base} (#{reason})" : base
+        Introspectors::StaticTier.unavailable_reason
       end
     end
   end

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "5.20.0"
+  VERSION = "5.20.1"
 end

data/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.19.1",
+  "version": "5.20.0",
   "packages": [
     {
       "registryType": "mcpb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.20.0
+  version: 5.20.1
 platform: ruby
 authors:
 - crisnahine