rails-ai-context 5.20.1 → 5.20.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7cbf76ef448db45165cf06f3c2af8303b23f8629a709b20ffb61ae33093c192
-  data.tar.gz: 65fe97840d3fd23ab66b1b8e6b108914b3675e3648c51d746769d4016b6a846a
+  metadata.gz: 81eedfa398603e64a27f7555b4288e39a11e41093c3a06450354c2f5cb1d17c5
+  data.tar.gz: 34972bf4259e8e12695f008744111bff94ed7caa93155bd3f8352010e3134c15
 SHA512:
-  metadata.gz: b4816a51648a6aaee1a3fd48b649ff35967e2efea2c75805da08c605a0668b8afa7dbe113b8d7f555a13c268d72f1284b69091a3b9d102465e3a6b00f5b2282b
-  data.tar.gz: cc12eaa6400a9a2906ca706b37fc92f211f0837e69038f14e6a25742be8207d529c915c4ecdb122c6bd2a20a9dc0eb86a3474cd4a65a321fa8ded9f2aa64a47d
+  metadata.gz: c88339dc6c73a5fdb38209d69e61437a6494382c069ae943478e51a265e57b2b847d4cb89f22ef0449c024bdb43185feef7e58a5e92f199c0a0389f4822898ca
+  data.tar.gz: 2f0a283b5691f00d4f49aeed839da56af13e248f566c9a526e3926cbc0c71185cf2e99a9b809d5e316d7e1144826456bb65ea36148493b4102f44b3bf0857584

data/CHANGELOG.md

@@ -5,6 +5,68 @@ 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.2] - 2026-08-11
+
+### Fixed
+
+- **A long-lived process no longer answers about the app as it was at boot.**
+  The MCP server and `watch` invalidated their own caches on a file change but
+  never reloaded Rails, and `Zeitwerk#eager_load_dir` does not re-scan a
+  directory it has already loaded - so a model written after the server started
+  stayed invisible for the life of the process, and the server told callers it
+  did not exist. Routes were unaffected because `RouteIntrospector` already
+  asked `routes_reloader.execute_if_updated`. Both change handlers now run
+  Rails' own reloader first, gated on `config.enable_reloading` (the flag that
+  decides whether Rails unloads anything - `eager_load` does not), and every
+  tool call and every resource read now runs inside the executor so a reload
+  cannot unload constants while one is reading them. A failing reload leaves
+  the process alive, and a tool failure is not reported to the host app's
+  error reporter - it is handled here and returned as an isError result.
+
+- **A `validates_with` validator no longer replaces the whole model answer.**
+  `ActiveModel::Validator` has no `#attributes` - only `EachValidator` does -
+  so one of them anywhere on a model turned `rails_get_model_details`,
+  `rails_get_callbacks` and `rails://models/X` into a single
+  "Error inspecting X" line. (#121)
+- **Static-tier callbacks are reported.** The two tiers handed back different
+  types for one key: a Hash keyed by callback type when booted, a flat Array
+  from the listener otherwise. Every consumer filters on `is_a?(Hash)`, so
+  `--no-boot` answered "No models with callbacks found" for an app full of
+  them, and `--model X --no-boot` raised `TypeError` on a Hash lookup against
+  an Array. (#122)
+- **`get_mailers` reports the actions Rails calls actions.** It listed
+  `instance_methods(false)`, which includes ActiveSupport's generated
+  `_run_*_callbacks` and any public helper, so an abstract `ApplicationMailer`
+  was reported as having deliverable actions. It now asks
+  `action_methods`. (#126)
+- **One answer to which database the app runs on.** Four surfaces each carried
+  their own substitute for the internal `static_parse` marker and disagreed:
+  the generated `CLAUDE.md`, `rails_get_schema`, `rails_onboard` and
+  `rails ai:inspect` could name three different databases for one app, and
+  `onboard`'s gem loop let the last match win where the serializer's let the
+  first. They now share `RailsAiContext::SchemaAdapter`, which resolves from
+  the app's own database configuration first, then the `structure.sql` dialect
+  already parsed, then the Gemfile - order-independent. (#125)
+- **Generated context files no longer print `Database: static_parse`.** That is
+  the internal marker for "read from db/schema.rb, not the connection";
+  `onboard` already substituted the live adapter and the serializers did
+  not. (#125)
+- **`get_job_pattern` says what it checked.** "This app may not use background
+  jobs" was a claim about the whole app drawn from one directory, and apps
+  keeping Sidekiq workers in `app/workers/` were told they have none. (#120)
+- **`validate`'s empty-files message advises a syntax the CLI accepts.** It
+  recommended `files:["..."]`, which the CLI reads as a literal filename. (#124)
+- **`validate --files a.rb b.rb` validates every file.** Array parameters
+  consumed only the first token, so the rest were dropped silently and the
+  summary read "1/1 files passed" for a set containing a broken file. (#124)
+
+### Added
+
+- **The static tier reads `config.api_only`.** Without a booted app the view
+  tools fell back to "no Stimulus controllers found" on an API-only app, where a
+  booted run says "Not applicable". Both were true, but only one of them stops
+  an agent adding a view layer to an app that has none by design.
+
 ## [5.20.1] - 2026-08-11
 
 ### Fixed

data/lib/rails_ai_context/app_kind.rb

@@ -27,5 +27,28 @@ module RailsAiContext
       content = RailsAiContext::SafeFile.read(gemfile)
       !!content&.match?(/^\s*gem\s+["']mongoid["']/)
     end
+
+    # An API-only app has no view layer, and saying "no Stimulus controllers
+    # found" about one invites an agent to add some. The flag is written in
+    # config/application.rb, so this answer needs no booted app.
+    #
+    # Read from the AST, not a regex: `config.api_only = true` is an
+    # assignment, which docs/INTROSPECTORS.md puts squarely in AST territory,
+    # and ConfigAssignmentListener already reports exactly this shape. A regex
+    # also has to hand-roll what the parser knows for free - comments, strings
+    # and heredocs that merely contain the text.
+    def api_only?(root)
+      path = File.join(root.to_s, "config", "application.rb")
+      return false unless File.exist?(path)
+      return false unless RailsAiContext::SafeFile.read(path)
+
+      walked = Introspectors::SourceIntrospector.walk(
+        path, { config: Introspectors::Listeners::ConfigAssignmentListener }
+      )
+      hit = Array(walked[:config]).find { |entry| entry[:path] == [ :api_only ] }
+      !hit.nil? && hit[:value] == true
+    rescue StandardError, ScriptError
+      false
+    end
   end
 end

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -211,7 +211,17 @@ module RailsAiContext
             if arg.include?("=")
               key, value = arg.sub("--", "").split("=", 2)
               key = key.tr("-", "_").to_sym
-              result[key] = coerce_value(value, properties[key] || {})
+              prop = properties[key] || {}
+              if prop[:type] == "array"
+                # `--files=a.rb b.rb` is the same call as `--files a.rb b.rb`;
+                # honouring only one of the two spellings docs/CLI.md teaches
+                # left the other still dropping every file after the first.
+                trailing = collect_array_values(args, i + 1)
+                result[key] = Array(coerce_value(value, prop)) + trailing
+                i += 1 + values_consumed(args, i + 1)
+                next
+              end
+              result[key] = coerce_value(value, prop)
             else
               key = arg.sub("--", "").tr("-", "_").to_sym
               prop = properties[key] || {}
@@ -232,6 +242,24 @@ module RailsAiContext
                 next
               end
 
+              if prop[:type] == "array"
+                values = collect_array_values(args, i + 1)
+                unless values.empty?
+                  result[key] = values
+                  i += 1 + values_consumed(args, i + 1)
+                  next
+                end
+              end
+
+              # A bare `--files` with nothing after it is a mistake, not a
+              # request for `files: true` - an array param holding a Boolean
+              # reaches the tool as a type it never accepts.
+              if prop[:type] == "array"
+                result[key] = []
+                i += 1
+                next
+              end
+
               value = (i + 1 < args.size) ? args[i + 1] : nil
               if value && !value.start_with?("--")
                 result[key] = coerce_value(value, prop)
@@ -258,6 +286,21 @@ module RailsAiContext
         result
       end
 
+      # Tokens belonging to an array flag: everything up to the next flag,
+      # stopping at a rake-style `key=value` token so `--include a model=Post`
+      # does not swallow the second parameter. Each token is still
+      # comma-split, so the documented `a.rb,b.rb` form keeps working and
+      # mixing the two spellings does not fabricate a path.
+      def collect_array_values(args, from)
+        args[from..].to_a
+            .take_while { |a| !a.start_with?("--") && !a.include?("=") }
+            .flat_map { |a| Array(coerce_value(a, { type: "array" })) }
+      end
+
+      def values_consumed(args, from)
+        args[from..].to_a.take_while { |a| !a.start_with?("--") && !a.include?("=") }.size
+      end
+
       # Coerce a string value to the type specified in the JSON Schema property.
       def coerce_value(raw, property_schema)
         case property_schema[:type]

data/lib/rails_ai_context/code_reloader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Re-runs Rails' own code reloader so a long-lived process sees files written
+  # after it booted.
+  #
+  # Clearing the gem's caches is not enough on its own. Introspectors reach the
+  # app through constants, and the eager loading they trigger
+  # (`Zeitwerk::Loader#eager_load_dir`) is idempotent per process - a directory
+  # already loaded is never re-scanned, so a model added after boot stays
+  # invisible for the life of the server. Routes never had the problem because
+  # RouteIntrospector asks `routes_reloader.execute_if_updated` every call.
+  module CodeReloader
+    module_function
+
+    # Reload the app's autoloaded code. Returns whether a reload actually ran,
+    # so callers can say what they did instead of guessing.
+    def reload!
+      return false unless reloadable?
+
+      Rails.application.reloader.reload!
+      true
+    rescue StandardError, ScriptError => e
+      # A broken file mid-edit is the common case. Zeitwerk reloads by
+      # unload-then-setup, so a raise can leave constants already unloaded -
+      # they re-autoload lazily on next reference. Either way a running server
+      # must survive it.
+      $stderr.puts "[rails-ai-context] code reload failed: #{e.class}: #{e.message}" if ENV["DEBUG"]
+      false
+    end
+
+    # Run a block with the sharing lock held, so a reload cannot unload
+    # constants underneath it.
+    #
+    # `Reloader#class_unload!` takes the unload lock through
+    # ActiveSupport::Dependencies.interlock, but that only blocks threads
+    # holding the sharing lock - which is acquired inside `executor.wrap`.
+    # Nothing here wrapped anything, so the Listen thread could clear
+    # DescendantsTracker while a tool call was midway through reading
+    # `ActiveRecord::Base.descendants`, returning a short list with no
+    # exception for the per-section rescue to notice.
+    #
+    # Only taken when a reload could actually happen; everywhere else this is
+    # a plain yield.
+    def with_app_code
+      return yield unless reloadable?
+
+      app = Rails.application
+      return yield unless app.respond_to?(:executor)
+
+      app.executor.wrap { yield }
+    end
+
+    # `enable_reloading` is the flag that decides whether Rails unloads
+    # anything: with it off, the finisher registers no class_unload callback,
+    # so `reload!` runs the prepare callbacks and returns having reloaded
+    # nothing. Gating on `eager_load` instead reported success for every
+    # eager_load=false + cache_classes=true environment (stock `test`, a
+    # cache-classes staging container) - a reload that never happened,
+    # announced as one.
+    def reloadable?
+      return false if RailsAiContext.static_tier?
+      return false unless defined?(Rails) && Rails.respond_to?(:application)
+
+      app = Rails.application
+      return false unless app.respond_to?(:reloader) && app.respond_to?(:config)
+
+      config = app.config
+      # Rails 7.1+ names it enable_reloading; older releases only have
+      # cache_classes, which is its inverse.
+      return config.enable_reloading if config.respond_to?(:enable_reloading)
+      return !config.cache_classes if config.respond_to?(:cache_classes)
+
+      false
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/api_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # versioning patterns, rate limiting.
     class ApiIntrospector
       extend StaticTier
-      static_tier :runtime_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -14,6 +14,20 @@ module RailsAiContext
         @app = app
       end
 
+      # Everything but api_only needs a booted app, but api_only itself is a
+      # plain assignment in config/application.rb - and the view tools already
+      # read it there. Leaving this section wholly unavailable meant one
+      # process answering "this is an API-only app" from get_stimulus and
+      # "cannot say" from get_api.
+      def static_call
+        {
+          api_only: AppKind.api_only?(app.root),
+          unavailable_sections: StaticTier.unavailable_reason
+        }
+      rescue StandardError
+        { unavailable: StaticTier.unavailable_reason }
+      end
+
       def call
         {
           api_only: app.config.api_only,

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -234,7 +234,14 @@ module RailsAiContext
         ActionMailer::Base.descendants.filter_map do |mailer|
           next if mailer.name.nil?
 
-          actions = mailer.instance_methods(false).map(&:to_s).sort
+          # Rails' own answer: it subtracts internal and inherited methods, so
+          # an abstract ApplicationMailer reports none and ActiveSupport's
+          # generated `_run_*_callbacks` never appears. `instance_methods(false)`
+          # listed both as deliverable actions. Called bare, like
+          # ControllerIntrospector does - AbstractController::Base has defined
+          # it across the whole supported range, so a fallback here would only
+          # be unreachable code holding the old bug.
+          actions = mailer.action_methods.to_a.map(&:to_s).sort
           next if actions.empty?
 
           {
@@ -248,8 +255,10 @@ module RailsAiContext
         []
       end
 
-      # A mailer's actions are its public instance methods, which is exactly
-      # what `instance_methods(false)` reports on the booted side.
+      # A mailer's actions are its public instance methods. The booted side asks
+      # `action_methods`, which also subtracts inherited and internal ones - the
+      # AST cannot see that, so a public helper on a concrete mailer is still
+      # listed here and not there.
       def extract_mailers_from_source
         source_classes(File.join(app.root, "app", "mailers")).filter_map do |name, methods|
           next if name == "ApplicationMailer"

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -222,7 +222,10 @@ module RailsAiContext
         model.validators.map do |validator|
           {
             kind: validator.kind.to_s,
-            attributes: validator.attributes.map(&:to_s),
+            # `validates_with` registers a bare ActiveModel::Validator, which
+            # has no #attributes - only EachValidator does. Calling it blind
+            # replaced the whole model's answer with one error line.
+            attributes: validator.respond_to?(:attributes) ? Array(validator.attributes).map(&:to_s) : [],
             options: sanitize_options(validator.options)
           }
         end
@@ -332,9 +335,15 @@ module RailsAiContext
       end
 
       def extract_callbacks_from_ast(source_data)
-        source_data[:callbacks].each_with_object({}) do |cb, hash|
-          type = cb[:type].to_s
-          (hash[type] ||= []) << cb[:method]
+        group_callbacks_by_type(source_data[:callbacks])
+      end
+
+      # One shape for both tiers: { "before_validation" => ["normalize"] }.
+      def group_callbacks_by_type(callbacks)
+        Array(callbacks).each_with_object({}) do |cb, hash|
+          next unless cb.is_a?(Hash) && cb[:type]
+
+          (hash[cb[:type].to_s] ||= []) << cb[:method]
         end
       end
 
@@ -576,7 +585,12 @@ module RailsAiContext
           validations: data[:validations],
           scopes: data[:scopes],
           enums: data[:enums],
-          callbacks: data[:callbacks],
+          # Same shape as the booted tier: a Hash keyed by callback type. The
+          # listener hands back a flat Array, and every consumer filters on
+          # `callbacks.is_a?(Hash)` - so passing it through rendered "No models
+          # with callbacks found" and then raised a TypeError on a Hash lookup
+          # against an Array.
+          callbacks: group_callbacks_by_type(data[:callbacks]),
           macros: data[:macros],
           methods: data[:methods]
         }
@@ -641,7 +655,12 @@ module RailsAiContext
           associations: data[:associations],
           validations: data[:validations],
           scopes: data[:scopes],
-          callbacks: data[:callbacks],
+          # Same shape as the booted tier: a Hash keyed by callback type. The
+          # listener hands back a flat Array, and every consumer filters on
+          # `callbacks.is_a?(Hash)` - so passing it through rendered "No models
+          # with callbacks found" and then raised a TypeError on a Hash lookup
+          # against an Array.
+          callbacks: group_callbacks_by_type(data[:callbacks]),
           methods: data[:methods]
         }
         collection = macros.find { |m| m[:macro] == :store_in }&.dig(:options, :collection)

data/lib/rails_ai_context/live_reload.rb

@@ -55,6 +55,11 @@ module RailsAiContext
 
       @last_fingerprint = Fingerprinter.compute(app)
 
+      # Order matters: reload the app's code first, then drop the caches built
+      # from the old constants. Clearing caches alone left the server answering
+      # from whatever Rails autoloaded at boot.
+      reloaded = CodeReloader.reload!
+
       # Invalidate all tool caches (includes AstCache.clear)
       Tools::BaseTool.reset_all_caches!
 
@@ -64,12 +69,12 @@ module RailsAiContext
       # Notify connected MCP clients
       mcp_server.notify_resources_list_changed
       mcp_server.notify_log_message(
-        data: "#{message} Tool caches invalidated.",
+        data: "#{message} Tool caches invalidated#{reloaded ? " and app code reloaded" : ""}.",
         level: "info",
         logger: "rails-ai-context"
       )
 
-      $stderr.puts "[rails-ai-context] #{message} Tool caches invalidated."
+      $stderr.puts "[rails-ai-context] #{message} Tool caches invalidated#{reloaded ? " and app code reloaded" : ""}."
     rescue => e
       $stderr.puts "[rails-ai-context] Live reload error: #{e.message}"
     end

data/lib/rails_ai_context/resources.rb

@@ -143,6 +143,13 @@ module RailsAiContext
       # the handler's return value into the JSON-RPC response without renaming
       # keys, so snake_case would leak to clients as-is.
       def handle_read(params)
+        # Resource reads introspect just like tool calls do, and they bypassed
+        # SafeCall entirely - so a live reload could unload constants while one
+        # was reading them and hand back a short list with nothing raised.
+        RailsAiContext::CodeReloader.with_app_code { read_resource(params) }
+      end
+
+      def read_resource(params)
         uri = params[:uri]
 
         # The two schemes are historical; accept either one for every

data/lib/rails_ai_context/schema_adapter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # One answer to "which database is this app on", for every surface that asks.
+  #
+  # `SchemaIntrospector` writes `static_parse` when it read `db/schema.rb`
+  # instead of the connection. That is an internal detail: printed raw it names
+  # a database that does not exist. Four call sites each grew their own
+  # substitute and gave three different answers for one app - the generated
+  # CLAUDE.md said PostgreSQL, `rails_get_schema` said unknown, `rails ai:inspect`
+  # said static_parse. This is the seam they share.
+  module SchemaAdapter
+    # Values that mean "no adapter was observed", not "the adapter is X".
+    PLACEHOLDERS = %w[static_parse unknown].freeze
+
+    # Gemfile display names, only as the last resort.
+    GEM_ADAPTERS = {
+      "pg" => "PostgreSQL",
+      "mysql2" => "MySQL",
+      "trilogy" => "MySQL",
+      "sqlite3" => "SQLite"
+    }.freeze
+
+    # structure.sql dialects, as SchemaIntrospector records them.
+    DIALECTS = {
+      "postgresql" => "PostgreSQL",
+      "mysql" => "MySQL",
+      "sqlite" => "SQLite"
+    }.freeze
+
+    module_function
+
+    # @param context [Hash] a full introspection context
+    # @return [String] the adapter to show, never an internal placeholder
+    def label(context)
+      context = {} unless context.is_a?(Hash)
+      schema = context[:schema]
+      observed = schema.is_a?(Hash) ? schema[:adapter] : nil
+      return observed unless placeholder?(observed)
+
+      # Best first: the app's own database config, which needs no connection.
+      # Then the dialect parsed out of structure.sql. Only then the Gemfile,
+      # which is a guess - an app can carry two adapter gems.
+      from_configurations(context) || from_dialect(schema) || from_gems(context) || "unknown"
+    end
+
+    def placeholder?(adapter)
+      adapter.nil? || PLACEHOLDERS.include?(adapter.to_s)
+    end
+
+    def from_configurations(context)
+      multi = context[:multi_database]
+      return nil unless Serializers::SectionGuard.usable?(multi)
+
+      primary = Array(multi[:databases]).find { |db| db[:name].to_s == "primary" } ||
+                Array(multi[:databases]).first
+      adapter = primary&.dig(:adapter)
+      return nil if placeholder?(adapter)
+
+      # These are ActiveRecord adapter names (`postgresql`, `sqlite3`), not gem
+      # names. The two overlap by accident at sqlite3/mysql2/trilogy, so
+      # reading only GEM_ADAPTERS let `postgresql` fall through raw - a Postgres
+      # app rendered "Database: postgresql" beside a SQLite app's "SQLite".
+      DIALECTS[adapter.to_s] || GEM_ADAPTERS[adapter.to_s] || adapter
+    end
+
+    def from_dialect(schema)
+      return nil unless schema.is_a?(Hash)
+
+      DIALECTS[schema[:dialect].to_s]
+    end
+
+    # Last, and order-independent: an app with both `pg` and `sqlite3` gets the
+    # same answer here as anywhere else, rather than depending on which match
+    # a loop happened to see last.
+    def from_gems(context)
+      gems = context[:gems]
+      return nil unless Serializers::SectionGuard.usable?(gems)
+
+      names = Array(gems[:notable_gems]).map { |g| g[:name].to_s }
+      GEM_ADAPTERS.each_key { |gem_name| return GEM_ADAPTERS[gem_name] if names.include?(gem_name) }
+      nil
+    end
+  end
+end

data/lib/rails_ai_context/serializers/claude_rules_serializer.rb

@@ -43,7 +43,7 @@ module RailsAiContext
         # Compact counts - gems and architecture are already in the root file (CLAUDE.md/AGENTS.md)
         schema = context[:schema]
         if SectionGuard.usable?(schema)
-          lines << "- Database: #{schema[:adapter]} - #{count_phrase(schema[:total_tables], "table")}"
+          lines << "- Database: #{database_adapter_label(schema)} - #{count_phrase(schema[:total_tables], "table")}"
         end
 
         models = context[:models]

data/lib/rails_ai_context/serializers/compact_serializer_helper.rb

@@ -26,7 +26,7 @@ module RailsAiContext
         schema = context[:schema]
         if SectionGuard.usable?(schema)
           tables = schema[:total_tables]
-          lines << "- Database: #{schema[:adapter]} - #{count_phrase(tables, "table")}"
+          lines << "- Database: #{database_adapter_label(schema)} - #{count_phrase(tables, "table")}"
         end
 
         models = context[:models]

data/lib/rails_ai_context/serializers/copilot_instructions_serializer.rb

@@ -45,7 +45,7 @@ module RailsAiContext
 
         schema = context[:schema]
         if SectionGuard.usable?(schema)
-          lines << "- Database: #{schema[:adapter]} - #{count_phrase(schema[:total_tables], "table")}"
+          lines << "- Database: #{database_adapter_label(schema)} - #{count_phrase(schema[:total_tables], "table")}"
         end
 
         models = context[:models]

data/lib/rails_ai_context/serializers/copilot_serializer.rb

@@ -29,7 +29,7 @@ module RailsAiContext
         schema = context[:schema]
         if SectionGuard.usable?(schema)
           tables = schema[:total_tables]
-          lines << "- Database: #{schema[:adapter]} - #{count_phrase(tables, "table")}"
+          lines << "- Database: #{database_adapter_label(schema)} - #{count_phrase(tables, "table")}"
         end
 
         models = context[:models]

data/lib/rails_ai_context/serializers/cursor_rules_serializer.rb

@@ -74,7 +74,7 @@ module RailsAiContext
 
         schema = context[:schema]
         if SectionGuard.usable?(schema)
-          lines << "- Database: #{schema[:adapter]} - #{count_phrase(schema[:total_tables], "table")}"
+          lines << "- Database: #{database_adapter_label(schema)} - #{count_phrase(schema[:total_tables], "table")}"
         end
 
         models = context[:models]

data/lib/rails_ai_context/serializers/stack_overview_helper.rb

@@ -213,6 +213,13 @@ module RailsAiContext
         $stderr.puts "[rails-ai-context] Before actions scan skipped: #{e.message}" if ENV["DEBUG"]
         []
       end
+
+      # One seam for every surface that names the database, so the generated
+      # files, the tools and the rake task cannot answer differently for one
+      # app. See RailsAiContext::SchemaAdapter.
+      def database_adapter_label(_schema = nil)
+        SchemaAdapter.label(context)
+      end
     end
   end
 end

data/lib/rails_ai_context/tasks/rails_ai_context.rake

@@ -438,7 +438,7 @@ namespace :ai do
     puts ""
 
     if context[:schema] && !context[:schema][:error]
-      puts "📦 Database: #{RailsAiContext::CountPhrase.call(context[:schema][:total_tables], "table")} (#{context[:schema][:adapter]})"
+      puts "📦 Database: #{RailsAiContext::CountPhrase.call(context[:schema][:total_tables], "table")} (#{RailsAiContext::SchemaAdapter.label(context)})"
     end
 
     if context[:models] && !context[:models].is_a?(Hash)

data/lib/rails_ai_context/tools/base_tool.rb

@@ -355,7 +355,15 @@ module RailsAiContext
           return api[:api_only] == true if api.is_a?(Hash) && api.key?(:api_only)
 
           app = rails_app
-          app.respond_to?(:config) && app.config.respond_to?(:api_only) && app.config.api_only == true
+          if app.respond_to?(:config) && app.config.respond_to?(:api_only)
+            return app.config.api_only == true
+          end
+
+          # Static tier: no booted config to ask, but the flag is declared in
+          # config/application.rb. Without this the view tools fall back to
+          # "none found", which reads as "not built yet" for an app that has
+          # no view layer by design.
+          AppKind.api_only?(app.root)
         rescue StandardError
           false
         end

data/lib/rails_ai_context/tools/get_job_pattern.rb

@@ -86,9 +86,9 @@ module RailsAiContext
       # directory is there (e.g. freshly generated by `rails new`).
       private_class_method def self.no_job_files_message(jobs_dir_exists)
         if jobs_dir_exists
-          "app/jobs/ exists but has no job classes beyond ApplicationJob. This app may not use background jobs."
+          "No job classes in app/jobs/ beyond ApplicationJob. Workers outside that directory (Sidekiq::Worker in app/workers/, for example) are not covered by this tool."
         else
-          "No app/jobs/ directory found. This app may not use background jobs."
+          "No app/jobs/ directory. Workers outside it (Sidekiq::Worker in app/workers/, for example) are not covered by this tool."
         end
       end
 
@@ -101,9 +101,9 @@ module RailsAiContext
       private_class_method def self.no_jobs_or_channels_message(jobs_dir_exists, channels_note)
         channels_clause = channels_note || "no Action Cable channels detected"
         if jobs_dir_exists
-          "app/jobs/ exists but has no job classes beyond ApplicationJob, and #{channels_clause}. This app may not use background jobs."
+          "No job classes in app/jobs/ beyond ApplicationJob, and #{channels_clause}. Workers outside that directory are not covered by this tool."
         else
-          "No app/jobs/ directory found and #{channels_clause}. This app may not use background jobs."
+          "No app/jobs/ directory and #{channels_clause}. Workers outside it are not covered by this tool."
         end
       end
 

data/lib/rails_ai_context/tools/get_schema.rb

@@ -95,7 +95,7 @@ module RailsAiContext
               return text_response("No tables at offset #{offset}. Total: #{total}. Use `offset:0` to start over.")
             end
             lines = [ "# Schema Summary (#{count_phrase(total, "table")})", "" ]
-            lines << "**Adapter:** #{schema[:adapter]}" if schema[:adapter]
+            lines << "**Adapter:** #{adapter_label(schema)}" if schema[:adapter]
             lines.concat(static_source_lines(schema))
             paginated.each do |name|
               data = tables[name]
@@ -209,6 +209,13 @@ module RailsAiContext
         end
       end
 
+      # The same seam the generated context files use. Answering this question
+      # locally is how one app came to be told it runs on PostgreSQL by
+      # CLAUDE.md and on "unknown" by this tool, in the same session.
+      private_class_method def self.adapter_label(_schema = nil)
+        RailsAiContext::SchemaAdapter.label(cached_context)
+      end
+
       private_class_method def self.models_for_table(table_name)
         models = cached_context[:models]
         return [] unless models.is_a?(Hash)
@@ -333,7 +340,7 @@ module RailsAiContext
         lines = [
           "# Database Schema",
           "",
-          "- Adapter: #{schema[:adapter]}",
+          "- Adapter: #{adapter_label(schema)}",
           "- Tables: #{schema[:total_tables]}",
           ""
         ]

data/lib/rails_ai_context/tools/onboard.rb

@@ -594,31 +594,11 @@ module RailsAiContext
           end
         end
 
-        # Resolve the DB adapter name, preferring live config over schema introspection
-        def resolve_db_adapter(ctx, schema)
-          adapter = schema[:adapter]
-
-          # If the schema introspector returned a non-informative adapter name, try config
-          if adapter.nil? || adapter == "static_parse" || adapter == "unknown"
-            config_data = ctx[:config]
-            if config_data.is_a?(Hash) && !config_data[:error]
-              live_adapter = config_data[:database_adapter] || config_data[:adapter]
-              adapter = live_adapter if live_adapter
-            end
-          end
-
-          # Try to resolve from gems as a fallback
-          if adapter.nil? || adapter == "static_parse" || adapter == "unknown"
-            gems_data = ctx[:gems]
-            if gems_data.is_a?(Hash) && !gems_data[:error]
-              notable = gems_data[:notable_gems] || []
-              adapter = "PostgreSQL" if notable.any? { |g| g[:name] == "pg" }
-              adapter = "MySQL" if notable.any? { |g| %w[mysql2 trilogy].include?(g[:name]) }
-              adapter = "SQLite" if notable.any? { |g| g[:name] == "sqlite3" }
-            end
-          end
-
-          adapter || "unknown"
+        # The gems loop here let the LAST match win, so an app carrying both pg
+        # and sqlite3 was told SQLite by onboard and PostgreSQL by the
+        # generated files. One seam, one answer.
+        def resolve_db_adapter(ctx, _schema = nil)
+          RailsAiContext::SchemaAdapter.label(ctx)
         end
 
         def central_models(models, limit = 5)

data/lib/rails_ai_context/tools/safe_call.rb

@@ -23,23 +23,38 @@ module RailsAiContext
         kwargs = normalize_detail(kwargs)
         Thread.current[:rails_ai_context_call_params] = session_params(kwargs)
 
-        append_note(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
+        # Held across the tool body: a concurrent live reload 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
+        # unhandled, which would page a team over a failure this method turns
+        # into an ordinary isError result. Nothing escapes the block, so
+        # nothing is reported.
+        RailsAiContext::CodeReloader.with_app_code do
+          begin
+            append_note(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
+            failure_response(e)
+          end
+        end
+      end
+
+      private
 
+      def failure_response(error)
         label = respond_to?(:tool_name) ? tool_name : name
-        origin = Array(e.backtrace).first.to_s
-        text = +"Tool #{label} failed: #{e.class}: #{e.message.to_s.lines.first&.strip}\n"
+        origin = Array(error.backtrace).first.to_s
+        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."
         MCP::Tool::Response.new([ { type: "text", text: text } ], error: true)
       end
 
-      private
-
       # The value the caller sent, when this tool takes a DetailLevel detail
       # and that value is not one of its levels.
       def discarded_detail(kwargs)

data/lib/rails_ai_context/tools/validate.rb

@@ -48,7 +48,16 @@ module RailsAiContext
       VALID_LEVELS = %w[syntax rails].freeze
 
       def self.call(files:, level: "syntax", server_context: nil)
-        return text_response("No files provided. Pass file paths relative to Rails root (e.g. files:[\"app/models/post.rb\"]).") if files.nil? || files.empty?
+        # Both spellings, because the JSON form this used to suggest is not
+        # something the CLI accepts - following the advice produced
+        # "file not found" with the literal brackets in the name.
+        if files.nil? || files.empty?
+          return text_response(
+            "No files provided. Pass paths relative to Rails root - " \
+            "CLI: `--files app/models/post.rb app/models/user.rb`, " \
+            "MCP: `files: [\"app/models/post.rb\"]`."
+          )
+        end
         return text_response("Too many files (#{files.size}). Maximum is #{max_files} per call.") if files.size > max_files
         return text_response("Unknown level: '#{level}'. Valid values: #{VALID_LEVELS.join(', ')}") unless VALID_LEVELS.include?(level)
 

data/lib/rails_ai_context/version.rb

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

data/lib/rails_ai_context/watcher.rb

@@ -72,6 +72,9 @@ module RailsAiContext
       @last_fingerprint = Fingerprinter.compute(app)
 
       $stderr.puts "[rails-ai-context] Changes detected, regenerating context files..."
+      # Without this the regenerated files describe the app as it was when the
+      # watcher started, not as it is now.
+      CodeReloader.reload!
       result = RailsAiContext.generate_context(format: :all)
       result[:written].each { |f| $stderr.puts "  Updated: #{f}" }
       result[:skipped].each { |f| $stderr.puts "  Unchanged: #{f}" }

data/server.json

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.20.1
+  version: 5.20.2
 platform: ruby
 authors:
 - crisnahine
@@ -278,6 +278,7 @@ files:
 - lib/rails_ai_context/boot_manager.rb
 - lib/rails_ai_context/cli.rb
 - lib/rails_ai_context/cli/tool_runner.rb
+- lib/rails_ai_context/code_reloader.rb
 - lib/rails_ai_context/confidence.rb
 - lib/rails_ai_context/configuration.rb
 - lib/rails_ai_context/count_phrase.rb
@@ -385,6 +386,7 @@ files:
 - lib/rails_ai_context/redaction.rb
 - lib/rails_ai_context/resources.rb
 - lib/rails_ai_context/safe_file.rb
+- lib/rails_ai_context/schema_adapter.rb
 - lib/rails_ai_context/schema_hint.rb
 - lib/rails_ai_context/schema_version.rb
 - lib/rails_ai_context/serializers.rb