rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/introspectors/listeners/callbacks_listener.rb

@@ -23,21 +23,53 @@ module RailsAiContext
 
         INLINE_BLOCK = "[inline_block]"
 
+        # turbo-rails' broadcast macros are callbacks too: each declares a
+        # commit callback per event, a lambda running the method named here
+        # (Turbo::Broadcastable::ClassMethods).
+        BROADCASTS = {
+          broadcasts: { "after_create_commit" => "broadcast_action_later_to", "after_update_commit" => "broadcast_replace_later",
+                        "after_destroy_commit" => "broadcast_remove" },
+          broadcasts_to: { "after_create_commit" => "broadcast_action_later_to", "after_update_commit" => "broadcast_replace_later_to",
+                           "after_destroy_commit" => "broadcast_remove_to" },
+          broadcasts_refreshes: { "after_create_commit" => "broadcast_refresh_later_to", "after_update_commit" => "broadcast_refresh_later",
+                                  "after_destroy_commit" => "broadcast_refresh" },
+          broadcasts_refreshes_to: { "after_commit" => "broadcast_refresh_later_to" }
+        }.freeze
+
         # Macros that call args.extract_options!, so a trailing braced hash is options, not a filter.
         EXTRACTS_OPTIONS = %i[
           before_validation after_validation after_commit after_rollback
           after_create_commit after_update_commit after_destroy_commit after_save_commit
         ].to_set.freeze
 
+        # `before_<event>` on a chain `define_model_callbacks` makes; outside the file that defines it
+        # (Paperclip's has_attached_file), only the booted model's chains say it is one.
+        MODEL_CALLBACK = /\A(?:before|after|around)_(\w+)\z/
+
+        # `library_chains: true` also keeps a callback on a chain the file does not define, under
+        # `library_chain`, for a caller that checks the model holds that chain.
+        def initialize(library_chains: false)
+          super()
+          @library_chains = library_chains
+        end
+
         def on_call_node_enter(node)
           return record_skip(node) if node.name == :skip_callback && in_scope?(node)
-          return unless CALLBACK_METHODS.include?(node.name) && in_scope?(node)
+          return record_broadcasts(node) if BROADCASTS.key?(node.name) && in_scope?(node)
+          return record_defined(node) if node.name == :define_model_callbacks && in_scope?(node)
+
+          standard = CALLBACK_METHODS.include?(node.name)
+          chain = MODEL_CALLBACK.match(node.name.to_s)&.[](1) unless standard
+          return unless (standard || chain) && in_scope?(node)
+
+          library_chain = chain unless defined_here.include?(node.name)
+          return if library_chain && !@library_chains
 
           # Sources, not literals: a lambda condition reads as the line the
           # file holds rather than as a marker.
           hash = options_hash(node)
           options = scope_options(receiver_name(node)).merge(extract_keyword_sources(node)).merge(hash_sources(hash))
-          emit(node, resolve_callback_types(node.name, options), callback_targets(node, hash), options)
+          emit(node, resolve_callback_types(node.name, options), callback_targets(node, hash), options, library_chain: library_chain)
         end
 
         ON_EVENT = "after_commit_on_"
@@ -60,6 +92,13 @@ module RailsAiContext
           type.to_s.start_with?(ON_EVENT)
         end
 
+        # What a broadcast macro's callbacks are listed as. Not a bare name:
+        # the model has no method of it, and Rails keeps each of its lambdas
+        # where it merges two callbacks of one method name.
+        def self.broadcast_target(macro)
+          "#{macro} (turbo-rails)"
+        end
+
         # The event such a type names, `"create"`, or nil.
         def self.event(type)
           type.to_s.delete_prefix(ON_EVENT) if names_event?(type)
@@ -117,10 +156,20 @@ module RailsAiContext
           end
         end
 
-        def emit(node, callback_types, targets, options)
+        def defined_here
+          @defined_here ||= Set.new
+        end
+
+        def record_defined(node)
+          only = Array(extract_keyword_options(node)[:only]).map(&:to_s)
+          kinds = only.empty? ? KINDS : KINDS & only
+          extract_symbol_args(node).each { |event| kinds.each { |kind| defined_here << :"#{kind}_#{event}" } }
+        end
+
+        def emit(node, callback_types, targets, options, library_chain: nil)
           targets.each do |method_name, confidence|
             callback_types.each do |callback_type|
-              @results << {
+              record = {
                 # The declared macro, so a renderer can print what the file
                 # says instead of the resolved type.
                 name:       node.name.to_s,
@@ -131,10 +180,35 @@ module RailsAiContext
                 location:   node.location.start_line,
                 confidence: confidence
               }
+              # A block has no method whose body could be read; its declaration is its source.
+              record.merge!(declaration(node)) if method_name == INLINE_BLOCK
+              record[:library_chain] = library_chain if library_chain
+              @results << record
             end
           end
         end
 
+        def record_broadcasts(node)
+          BROADCASTS[node.name].each do |type, runs|
+            @results << {
+              name:       node.name.to_s,
+              type:       type,
+              method:     self.class.broadcast_target(node.name),
+              # Its options are the broadcast's rendering, never a callback condition.
+              options:    {},
+              runs:       runs,
+              owner:      @owner_stack.dup,
+              location:   node.location.start_line,
+              confidence: confidence_for(node)
+            }.merge(declaration(node))
+          end
+        end
+
+        # The call as the file writes it, at the file's indentation.
+        def declaration(node)
+          { source: (" " * node.location.start_column) + NodeSource.text(node), end_location: node.location.end_line }
+        end
+
         # `after_commit on: :create` is the after_commit_on_create type. One
         # declaration for several events stays one callback, its on: kept.
         def resolve_callback_types(name, options)

data/lib/rails_ai_context/introspectors/listeners/config_assignment_listener.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pathname"
+require "prism"
 
 module RailsAiContext
   module Introspectors

data/lib/rails_ai_context/introspectors/listeners/env_access_listener.rb

@@ -80,11 +80,20 @@ module RailsAiContext
             # `ENV.fetch("PORT", defaults[:port])` has a default, but naming
             # it `defaults[:port]` puts a Ruby expression where a reader
             # expects something to copy into a .env file.
-            default:     literal_value(args[1]),
+            default:     args.size > 1 ? literal_value(args[1]) : block_value(node.block),
             location:    node.location.start_line
           }
         end
 
+        # `ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" }`: a block whose
+        # one statement is a literal is that default, as a second argument is.
+        def block_value(block)
+          statements = block.body if block.is_a?(Prism::BlockNode)
+          return unless statements.is_a?(Prism::StatementsNode) && statements.body.size == 1
+
+          literal_value(statements.body.first)
+        end
+
         def literal_value(node)
           case node
           when Prism::StringNode  then node.unescaped

data/lib/rails_ai_context/introspectors/listeners/foreign_evals_listener.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # The blocks a class body evaluates on another receiver (`translation_class.class_eval do`),
+      # each with the source of every outermost call, by the line it starts on.
+      class ForeignEvalsListener < BaseListener
+        def initialize
+          super
+          @def_depth = 0
+          @open = []
+          @conditions = []
+        end
+
+        # An if or unless condition (`validates :x unless Rails.env.test?`) is not a declaration.
+        def on_if_node_enter(node)
+          @conditions << node.predicate.location
+        end
+
+        def on_unless_node_enter(node)
+          @conditions << node.predicate.location
+        end
+
+        def on_def_node_enter(_node)
+          @def_depth += 1
+        end
+
+        def on_def_node_leave(_node)
+          @def_depth -= 1
+        end
+
+        def on_call_node_enter(node)
+          @open.each { |_, block| record(block, node) }
+          return unless @def_depth.zero? && CallSiteExpansion.foreign_eval?(node)
+
+          body = node.block.location
+          block = { receiver: node.receiver.slice, lines: body.start_line..body.end_line, span: node.location.length, calls: {} }
+          @results << block
+          @open << [ node, block ]
+        end
+
+        def on_call_node_leave(node)
+          @open.pop if @open.last&.first.equal?(node)
+        end
+
+        private
+
+        # A call inside one already recorded on its line (`-> { order(:id) }`) is part of that one.
+        def record(block, node)
+          return if @conditions.any? { |condition| node.location.start_offset.between?(condition.start_offset, condition.end_offset - 1) }
+
+          calls = (block[:calls][node.location.start_line] ||= [])
+          return if calls.any? { |call| call[:range].cover?(node.location.start_offset) }
+
+          calls << { range: node.location.start_offset...node.location.end_offset, source: CallSiteExpansion.call_source(node) }
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/listeners/macros_listener.rb

@@ -30,19 +30,24 @@ module RailsAiContext
         STORE_MACROS = %i[store store_accessor].to_set.freeze
 
         BROADCAST_MACROS = %i[
-          broadcasts broadcasts_to broadcasts_refreshes_to
+          broadcasts broadcasts_to broadcasts_refreshes broadcasts_refreshes_to
         ].to_set.freeze
 
         # Model gems' class macros, each listed as written; aasm's block is read in full.
+        # `devise` names the modules a model turns on, which no other line says.
         GEM_MACROS = %i[
+          devise
           has_paper_trail audited acts_as_paranoid friendly_id
           mount_uploader mount_uploaders monetize
           pg_search_scope multisearchable searchkick
           acts_as_list acts_as_tenant multi_tenant acts_as_taggable acts_as_taggable_on
           has_ancestry acts_as_nested_set has_closure_tree acts_as_tree
-          state_machine workflow
+          state_machine workflow has_attached_file
         ].to_set.freeze
 
+        # Listed by the macro and its first argument: the options are lambdas that read as noise on one line.
+        NAMED_ONLY_MACROS = %i[has_attached_file].to_set.freeze
+
         def initialize
           super
           @def_depth = 0
@@ -160,8 +165,12 @@ module RailsAiContext
         end
 
         def record_gem_macro(node)
-          text = one_line_source(node, upto: node.block&.location&.start_offset)
-          text = text.gsub(/\s+/, " ").strip
+          first = node.arguments&.arguments&.first
+          text = if NAMED_ONLY_MACROS.include?(node.name) && first
+            "#{node.name} #{first.slice}"
+          else
+            one_line_source(node, upto: node.block&.location&.start_offset).gsub(/\s+/, " ").strip
+          end
           adds = monetized_names(node) if node.name == :monetize
           @results << { macro: :gem_macro, name: node.name, text: text, adds: adds.presence,
                         location: node.location.start_line, confidence: confidence_for(node) }.compact

data/lib/rails_ai_context/introspectors/listeners/migration_dsl_listener.rb

@@ -74,6 +74,7 @@ module RailsAiContext
           if node.name == :rename_table
             result[:new_name] = literal_string(args[1])
           end
+          result.merge!(default_fields(node, key: true)) if action == :create_table
 
           @results << result
         end
@@ -96,7 +97,7 @@ module RailsAiContext
           when :rename_column
             result[:new_name] = literal_string(args[2])
           when :change_column
-            result[:column_type] = literal_string(args[2])
+            result.merge!(column_type: literal_string(args[2]), **default_fields(node))
           when :change_column_null
             # The nullability is the third positional, not a keyword.
             result[:null] = boolean_value(args[2])

data/lib/rails_ai_context/introspectors/listeners/migration_replay_listener.rb

@@ -99,12 +99,13 @@ module RailsAiContext
           when :remove_index then result[:columns] = literal_strings(positional.first)
           when :rename_column then result.merge!(column: names[0], new_name: names[1])
           when :rename_index then result.merge!(old_name: names[0], new_name: names[1])
-          when :change_column then result.merge!(column: names[0], column_type: names[1])
+          when :change_column
+            result.merge!(column: names[0], column_type: names[1], **default_fields(node))
           when :change_column_null then result.merge!(column: names[0], null: boolean_value(positional[1]))
           when :change_column_default
             result[:column] = names[0]
             result[:new_default] = extract_value(positional[1]) if positional[1]
-          when :add_timestamps then result.merge!(default_source: default_source(node), default_proc: proc_default?(node))
+          when :add_timestamps then result.merge!(default_fields(node))
           when :add_check_constraint, :remove_check_constraint then result[:expression] = names[0]
           end
           result

data/lib/rails_ai_context/introspectors/listeners/routes_dsl_listener.rb

@@ -24,8 +24,11 @@ module RailsAiContext
         # `direct` and `resolve` define URL helpers and draw no route.
         URL_HELPER_MACROS = %i[direct resolve].freeze
         # Calls that draw routes; an unknown block that makes none of them configures a gem macro.
-        ROUTE_METHODS = (VERB_METHODS + %i[match namespace scope resources resource member collection new shallow
+        ROUTE_METHODS = (VERB_METHODS + %i[match namespace scope resources resource member collection new nested shallow
                                            concern concerns with_options controller mount root draw devise_for]).freeze
+        # Blocks that draw their routes where they stand: Rails' constraints and defaults, Devise's, and route_translator's.
+        # Any other method's block may scope its routes in a way the walk cannot see.
+        IN_PLACE_BLOCKS = %i[constraints defaults devise_scope as authenticate authenticated unauthenticated localized].freeze
         # Statement-level calls that draw nothing into the table.
         NON_ROUTING = %i[require require_relative puts p pp print warn raise default_url_options extend include].freeze
 
@@ -38,9 +41,11 @@ module RailsAiContext
         # `route_set` answers { prefix:, name_prefix: } for an app class that draws routes.
         # `names` is the set of route names taken so far, shared by every file of one table.
         # `multi_path`: the app's Rails draws every path of `get "/a", "/b"`; 8.1 raises instead.
-        def initialize(scope: [], route_set: nil, names: Set.new, multi_path: false)
+        # `api_only`: the app sets config.api_only, so its own table draws no new or edit route.
+        def initialize(scope: [], route_set: nil, names: Set.new, multi_path: false, api_only: false)
           super()
           @multi_path = multi_path
+          @api_only = api_only
           @stack = scope.map { |frame| frame.merge(node: nil) }
           @route_set = route_set
           @concern_blocks = {}
@@ -93,6 +98,8 @@ module RailsAiContext
           when :member then enter_member_collection(node, :member)
           when :collection then enter_member_collection(node, :collection)
           when :new then enter_member_collection(node, :new)
+          # A resource's frame already holds its nested scope, which a direct child draws under too.
+          when :nested then push_frame(node, suppress: current_resource.nil?) if node.block
           when :shallow then push_frame(node, shallow: true) if node.block
           when :concern then define_concern(node)
           when :concerns then apply_concerns(node)
@@ -107,20 +114,25 @@ module RailsAiContext
           else
             if statement && node.block
               # An empty block (a commented-out `constraints do`) configures nothing.
-              push_frame(node, unknown_block: @routing_calls, pending: []) if node.block.body
+              push_frame(node, unknown_block: @routing_calls, pending: [], suppress: !IN_PLACE_BLOCKS.include?(node.name)) if node.block.body
             elsif statement && !NON_ROUTING.include?(node.name)
               call_method_or_count(node)
             end
           end
         end
 
-        # An unknown block that draws no route is a gem macro (`use_doorkeeper do`), counted once.
+        # An unknown block that draws no route is a gem macro (`use_doorkeeper do`), counted once,
+        # and so is one whose routes it does not draw in place.
         def on_call_node_leave(node)
           return unless @stack.last && @stack.last[:node].equal?(node)
 
           frame = @stack.pop
           return unless frame[:unknown_block]
-          return frame[:pending].each { |call| emit_dynamic(call) } if frame[:unknown_block] != @routing_calls
+          if frame[:unknown_block] != @routing_calls
+            return emit_dynamic(node) if frame[:suppress]
+
+            return frame[:pending].each { |call| emit_dynamic(call) }
+          end
 
           outer = open_unknown_block
           outer ? outer[:pending] << node : emit_dynamic(node)
@@ -248,6 +260,12 @@ module RailsAiContext
           @stack.reverse.find { |f| f[:route_set] }&.dig(:route_set)
         end
 
+        # The app's config.api_only reaches its own route set only: an engine's
+        # table, or a route set class the app draws, keeps its own setting.
+        def api_only_table?
+          @api_only && @stack.none? { |f| f[:engine] || f[:route_set] }
+        end
+
         # The controller a route without one of its own takes: the innermost
         # `scope(controller:)` or resource, else Rails' module path alone.
         def current_controller
@@ -610,7 +628,7 @@ module RailsAiContext
           member = layout[:member_path]
           member_name = layout[:member_name]
           controller = resource_controller(name, opts, singular: singular)
-          actions = requested_actions(singular ? SINGULAR_ACTIONS : PLURAL_ACTIONS, opts)
+          actions = requested_actions(singular ? SINGULAR_ACTIONS : PLURAL_ACTIONS, opts, api_only: api_only_table?)
 
           actions.each do |action|
             case action
@@ -751,7 +769,7 @@ module RailsAiContext
         # @return [Array<[String, Boolean]>] each path, and whether it names an action
         def literal_paths(node)
           args = (node.arguments&.arguments || []).select { |a| a.is_a?(Prism::StringNode) || a.is_a?(Prism::SymbolNode) }
-          args.sort_by { |a| a.is_a?(Prism::StringNode) ? 0 : 1 }.map { |a| [ a.unescaped, a.is_a?(Prism::SymbolNode) ] }
+          args.partition { |a| a.is_a?(Prism::StringNode) }.flatten.map { |a| [ a.unescaped, a.is_a?(Prism::SymbolNode) ] }
         end
 
         def emit_verb_path(node, verb, segment, action_given, opts, rocket_key)
@@ -949,8 +967,11 @@ module RailsAiContext
           end
         end
 
-        def requested_actions(all, opts)
+        # Rails' Resource#default_actions: an api_only route set leaves out new
+        # and edit, unless `only:` asks for them by name.
+        def requested_actions(all, opts, api_only: false)
           actions = all
+          actions -= %i[new edit] if api_only && !opts[:only]
           actions &= Array(opts[:only]).map(&:to_sym) if opts[:only]
           actions -= Array(opts[:except]).map(&:to_sym) if opts[:except]
           actions

data/lib/rails_ai_context/introspectors/listeners/schema_dsl_listener.rb

@@ -168,6 +168,7 @@ module RailsAiContext
             # id: false / id: :uuid / primary_key: ... decide whether the
             # implicit primary-key column exists and what to call it.
             options:  extract_keyword_options(node),
+            **default_fields(node, key: true),
             location: node.location.start_line
           }
         end
@@ -321,8 +322,7 @@ module RailsAiContext
               options:     options,
               # A proc default (`default: -> { "now()" }`) has no literal value,
               # so keep its source for callers that report defaults verbatim.
-              default_source: default_source(node),
-              default_proc: proc_default?(node),
+              **default_fields(node),
               location:    node.location.start_line
             }
             @results.last[:virtual] = true if virtual

data/lib/rails_ai_context/introspectors/listeners/scopes_listener.rb

@@ -12,27 +12,52 @@ module RailsAiContext
         # in a block, not in a LambdaNode.
         LAMBDA_METHODS = %i[lambda proc].to_set.freeze
 
+        # A block these run once per element of the list they are sent to.
+        LOOPS = %i[each each_with_index].to_set.freeze
+
+        def initialize
+          super
+          @lists = {}
+          @loops = []
+        end
+
         def on_call_node_enter(node)
+          enter_loop(node)
           return record_default_scope(node) if node.name == :default_scope && in_scope?(node)
           return unless node.name == :scope && in_scope?(node)
 
           name = extract_first_symbol(node)
-          return if name == "[INFERRED]"
+          names = name == "[INFERRED]" ? loop_names(node.arguments&.arguments&.first) : [ name ]
+          return unless names
 
           callable = scope_body_node(node)
           body = callable ? lambda_body_source(callable) : nil
 
-          @results << {
-            name:            name.to_s,
-            body:            body,
-            required_params: callable ? lambda_required_params(callable) : [],
-            location:        node.location.start_line,
-            # A lambda body sliced verbatim from source IS the scope's ground
-            # truth; only scopes whose body can't be extracted (block form,
-            # metaprogrammed) are heuristic.
-            confidence:      body ? Confidence::VERIFIED : Confidence::INFERRED,
-            owner:           @owner_stack.dup
-          }
+          names.each do |scope_name|
+            @results << {
+              name:            scope_name.to_s,
+              body:            body,
+              required_params: callable ? lambda_required_params(callable) : [],
+              location:        node.location.start_line,
+              # A lambda body sliced verbatim from source IS the scope's ground
+              # truth; only scopes whose body can't be extracted (block form,
+              # metaprogrammed) are heuristic, and so is a name a loop gives.
+              confidence:      body && name != "[INFERRED]" ? Confidence::VERIFIED : Confidence::INFERRED,
+              owner:           @owner_stack.dup
+            }
+          end
+        end
+
+        def on_call_node_leave(node)
+          @loops.pop if @loops.last && @loops.last[:node].equal?(node)
+          super if defined?(super)
+        end
+
+        # A list a loop below can name by its constant.
+        def on_constant_write_node_enter(node)
+          values = literal_list(node.value)
+          @lists[node.name] = values if values
+          super
         end
 
         # Rails calls a `def self.default_scope` the model defines, as it does the macro's lambda.
@@ -55,6 +80,57 @@ module RailsAiContext
 
         private
 
+        # `KINDS.each { |kind| scope kind, -> { where(kind: kind) } }` declares a
+        # scope per element. Over a literal list - written inline, or a constant
+        # this file assigns one - the names are known before anything runs.
+        def enter_loop(node)
+          return unless LOOPS.include?(node.name) && node.arguments.nil? && node.block.is_a?(Prism::BlockNode)
+
+          param = node.block.parameters&.parameters&.requireds&.first
+          return unless param.is_a?(Prism::RequiredParameterNode)
+
+          receiver = node.receiver
+          values = receiver.is_a?(Prism::ConstantReadNode) ? @lists[receiver.name] : literal_list(receiver)
+          @loops.push({ node: node, param: param.name, values: values }) if values
+        end
+
+        # `%w[a b]`, `%i[a b]` or `[:a, "b"]`, frozen or not; nil for anything else.
+        def literal_list(node)
+          node = node.receiver while node.is_a?(Prism::CallNode) && node.name == :freeze && node.arguments.nil? && node.receiver
+          return nil unless node.is_a?(Prism::ArrayNode)
+
+          values = node.elements.map { |element| literal_string(element) }
+          values unless values.any?(&:nil?)
+        end
+
+        # One name per element of the innermost loop the name reads, or nil when it reads none.
+        def loop_names(arg)
+          @loops.reverse_each do |loop|
+            names = loop[:values].map { |value| loop_name(arg, loop[:param], value) }
+            return names.uniq unless names.any?(&:nil?)
+          end
+          nil
+        end
+
+        # The name an element gives: the block's variable as written, `.to_sym`'d,
+        # or interpolated into a symbol or a string.
+        def loop_name(arg, param, value)
+          case arg
+          when Prism::LocalVariableReadNode
+            value if arg.name == param
+          when Prism::CallNode
+            loop_name(arg.receiver, param, value) if %i[to_sym to_s intern].include?(arg.name) && arg.arguments.nil?
+          when Prism::InterpolatedSymbolNode, Prism::InterpolatedStringNode
+            parts = arg.parts.map do |part|
+              next part.unescaped if part.is_a?(Prism::StringNode)
+
+              statements = part.statements&.body if part.is_a?(Prism::EmbeddedStatementsNode)
+              loop_name(statements.first, param, value) if statements&.size == 1
+            end
+            parts.join unless parts.any?(&:nil?)
+          end
+        end
+
         # Named `default_scope` and marked `default`: it is no method to call,
         # and Rails stacks every one onto each query the model runs.
         def record_default_scope(node)

data/lib/rails_ai_context/introspectors/middleware_introspector.rb

@@ -86,7 +86,7 @@ module RailsAiContext
       def middleware_files(middleware_dir)
         return [] unless Dir.exist?(middleware_dir)
 
-        Dir.glob(File.join(middleware_dir, "**/*.rb")).sort.filter_map { |path| describe_middleware(path) }
+        FileWalk.glob(middleware_dir, "**/*.rb", root: root).filter_map { |path| describe_middleware(path) }
       end
 
       # The name comes from the declaration: a class under lib/middleware may
@@ -199,7 +199,7 @@ module RailsAiContext
       # often as an initializer does.
       def middleware_config_files
         PathResolver.initializer_paths(root) +
-          Dir.glob(File.join(root, "config/environments/*.rb")).sort +
+          Dir.glob(File.join(root, "config/environments/*.rb")).sort.reject { |path| PathResolver.linked_out?(path, root) } +
           [ File.join(root, "config/application.rb") ].select { |path| File.file?(path) }
       end
 

data/lib/rails_ai_context/introspectors/migration_introspector.rb

@@ -20,6 +20,8 @@ module RailsAiContext
         # list would read as "up to date".
         pending = pending_migrations
         info[:pending] = pending if pending
+        secondary = secondary_databases
+        info[:secondary_databases] = secondary if secondary.any?
         info
       end
 
@@ -72,6 +74,31 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, nil, label: "current_schema_version")
       end
 
+      # The other databases `db:migrate` runs here, each from its own
+      # migrations_paths, keyed by database.yml name. Pending is what the
+      # database's dump records, as the schema section reads that database;
+      # one that shares the primary's directories adds no files of its own.
+      def secondary_databases
+        dumps = SchemaDumpPath.secondaries(root)
+        RailsAiContext::DatabaseYml.task_secondaries(root).each_with_object({}) do |(name, entry), found|
+          dirs = MigrationReplay.configured_dirs(root, entry)
+          next if dirs.nil? || dirs == migrate_dir
+
+          files = RailsAiContext::PendingMigrations.migration_files(dirs, root: root)
+          next if files.empty?
+
+          format, dump = dumps[name]
+          pending = RailsAiContext::PendingMigrations.for(migrate_dir: dirs, applied: RailsAiContext::SchemaVersion.recorded(format, dump), root: root)
+          found[name] = {
+            total: files.size,
+            migrations_paths: dirs.select { |dir| Dir.exist?(dir) }.map { |dir| dir.delete_prefix("#{root.chomp('/')}/") },
+            pending: pending
+          }.compact
+        end
+      rescue => e
+        RailsAiContext.debug_fail(e, {}, label: "secondary_databases")
+      end
+
       def migration_stats
         return {} if all_migrations.empty?
 

data/lib/rails_ai_context/introspectors/migration_replay/helpers.rb

@@ -72,7 +72,7 @@ module RailsAiContext
                 rescues.none? { |r| r.cover?(call.location.start_line) }
             end
             items = own.map { |e| [ e[:location], 0, e ] } + called.map { |c| [ c.location.start_line, 1, c ] }
-            items.sort_by { |line, kind, _| [ line, kind ] }.each do |_, kind, item|
+            items.sort_by.with_index { |(line, kind, _), i| [ line, kind, i ] }.each do |_, kind, item|
               if kind.zero?
                 expanded << item.merge(location: anchor || item[:location], order: (order += 1))
               else