rails-ai-context 5.30.1 → 5.30.2

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -21,7 +21,7 @@ module RailsAiContext
         result = controllers.each_with_object({}) do |ctrl, hash|
           hash[ctrl.name] = extract_controller_details(ctrl)
         rescue => e
-          hash[ctrl.name] = { error: e.message }
+          hash[ctrl.name] = { error: portable_message(e) }
         end
 
         # Discover controllers from filesystem that may not be loaded as classes.
@@ -52,7 +52,7 @@ module RailsAiContext
 
           hash[name] = details[:error] ? details : details.merge(confidence: Confidence::STATIC)
         rescue => e
-          hash[path_name] = { error: e.message }
+          hash[path_name] = { error: portable_message(e) }
         end
         {
           controllers: fill_inherited_actions(result),
@@ -224,7 +224,12 @@ module RailsAiContext
         }.compact
         details
       rescue => e
-        { error: e.message }
+        { error: portable_message(e) }
+      end
+
+      # The context is committed, so a load error names the file as the app does.
+      def portable_message(error)
+        PortablePath.relativize_text(error.message, app.root)
       end
 
       def extract_controller_details(ctrl)
@@ -313,7 +318,7 @@ module RailsAiContext
             # Collect only/except constraints from source files in the inheritance chain
             source_constraints = collect_source_constraints(ctrl, source)
             reflection_filters.each do |f|
-              if (sc = source_constraints[f[:name]])
+              if (sc = source_constraints[[ f[:kind], f[:name] ]])
                 f[:only] = sc[:only] if sc[:only]&.any?
                 f[:except] = sc[:except] if sc[:except]&.any?
                 f[:unless] = sc[:unless] if sc[:unless]
@@ -324,7 +329,7 @@ module RailsAiContext
             # Evaluate known runtime conditions to remove inapplicable filters
             reflection_filters.reject! { |f| filter_excluded_by_condition?(ctrl, f) }
 
-            return merge_own_source(reflection_filters, source || read_source(ctrl))
+            return merge_own_source(reflection_filters, source || read_source(ctrl), ctrl)
           end
         end
 
@@ -349,12 +354,8 @@ module RailsAiContext
         while klass&.name && !ActionResolver.framework?(klass, kind: :controller)
           src = (klass == ctrl) ? (current_source || read_source(klass)) : read_source(klass)
           if src
-            extract_filters_from_source(src).each do |sf|
-              next if sf[:skipped]
-
-              # First definition wins (most specific controller in chain)
-              constraints[sf[:name]] ||= sf
-            end
+            # Within one body the last declaration wins; across the chain the most specific class does.
+            effective_declarations(own_filters(src, klass.name)).each { |key, sf| constraints[key] ||= sf }
           end
           klass = klass.superclass
         end
@@ -371,19 +372,45 @@ module RailsAiContext
       # spliced in beside the record it takes out, and the body's order
       # decides only whether the skip reads before or after a re-declaration
       # of the same name.
-      def merge_own_source(filters, source)
+      # A concern the body includes declares as the body does, so it is read
+      # the way the static tier reads it and keeps its `from_concern`.
+      def merge_own_source(filters, source, ctrl)
         return filters unless source
 
-        own = extract_filters_from_source(source)
-        declared = own.reject { |f| f[:skipped] }.map { |f| f[:name] }.to_set
-        by_name = filters.group_by { |f| f[:name] }
-        declared.each { |name| Array(by_name[name]).each { |f| f[:declared] = true } }
+        own = own_filters(source, ctrl.name).reject { |f| inherited_concern?(ctrl, f[:from_concern]) }
+        # Kind and name: `after_action :audit` inherited beside an own
+        # `before_action :audit` is still the ancestor's.
+        by_key = filters.group_by { |f| [ f[:kind], f[:name] ] }
+        effective_declarations(own).each do |key, declared|
+          Array(by_key[key]).each do |f|
+            f[:declared] = true
+            declared[:from_concern] ? f[:from_concern] = declared[:from_concern] : f.delete(:from_concern)
+          end
+        end
         skips = own.select { |f| f[:skipped] }
         return filters if skips.empty?
 
         splice_skips(filters, own, skips)
       end
 
+      # ActiveSupport::Concern skips a module already in the ancestors; a plain module's hook runs again.
+      def inherited_concern?(ctrl, label)
+        return false unless label && ctrl.superclass
+
+        mod = SuperclassChain.resolve_in_scope(ctrl.name, label) { |candidate| candidate.safe_constantize }
+        mod.is_a?(ActiveSupport::Concern) && ctrl.superclass.include?(mod)
+      end
+
+      def own_filters(source, within)
+        ControllerFilters.with_concerns(source, root: app.root.to_s, within: within.to_s,
+                                                cache: (@concern_cache ||= {})).first
+      end
+
+      # A later declaration of the same kind and name replaces the earlier one, as Rails does.
+      def effective_declarations(own)
+        own.reject { |f| f[:skipped] }.to_h { |f| [ [ f[:kind], f[:name] ], f ] }
+      end
+
       def splice_skips(filters, own, skips)
         placed = Set.new
         merged = filters.flat_map do |f|

data/lib/rails_ai_context/introspectors/eager_load.rb

@@ -43,22 +43,34 @@ module RailsAiContext
         end
       end
 
+      # SourceScan records, each loaded by the constant its file holds. Without
+      # the loader's answer (Zeitwerk < 2.6.9) the source's own declaration names
+      # it: path_name reads app/services/x.rb as Services::X.
+      def files(records)
+        loader = Rails.autoloaders.main
+        records.each do |record|
+          names = [ expected_cpath(loader, record.path) ].compact
+          names = DeclaredConstant.declarations(record.source).map(&:name) if names.empty?
+          names = [ record.path_name ] if names.empty?
+          names.each(&:constantize)
+        rescue StandardError, ScriptError => e
+          RailsAiContext.debug_fail(e, label: "load #{record.file}")
+        end
+      end
+
       # The loader declines a file it does not manage (a pack or an in-repo
       # engine runs its own), by nil or by raising; camelize still names it
       # well enough for that loader's autoload to answer.
       def cpath_for(loader, path, file)
-        if loader.respond_to?(:cpath_expected_at)
-          begin
-            cpath = loader.cpath_expected_at(file)
-            return cpath if cpath
-          rescue Zeitwerk::Error
-            nil
-          end
-        end
+        expected_cpath(loader, file) || file.delete_prefix(path + File::SEPARATOR).sub(/\.rb\z/, "").camelize
+      end
 
-        file.delete_prefix(path + File::SEPARATOR).sub(/\.rb\z/, "").camelize
+      def expected_cpath(loader, file)
+        loader.cpath_expected_at(file) if loader.respond_to?(:cpath_expected_at)
+      rescue Zeitwerk::Error
+        nil
       end
-      private_class_method :load_dir, :load_individually, :cpath_for
+      private_class_method :load_dir, :load_individually, :cpath_for, :expected_cpath
     end
   end
 end

data/lib/rails_ai_context/introspectors/i18n_introspector.rb

@@ -11,11 +11,12 @@ module RailsAiContext
 
       # 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.
+      # `I18n.default_locale = :es` in an initializer, which may also reach
+      # config through `Rails.application.config.i18n`.
       # Anchored past the line start so a commented example does not win:
       # GitLab ships `# config.i18n.default_locale = :de` and every coverage
       # line then measured an English app against German.
-      DEFAULT_LOCALE_ASSIGNMENT = /^[^\S\n]*(config\.i18n|I18n)\.default_locale\s*=\s*[:"']([\w-]+)/
+      DEFAULT_LOCALE_ASSIGNMENT = /^[^\S\n]*((?:(?:::)?Rails\.(?:application\.config|configuration)|config)\.i18n|I18n)\.default_locale\s*=\s*[:"']([\w-]+)/
 
       # `config.i18n.available_locales`, and only that: the listener strips the
       # root it matched, so a bare `config.available_locales` is any gem's own
@@ -102,7 +103,7 @@ module RailsAiContext
       end
 
       def spelling_of(prefix)
-        prefix.start_with?("config") ? :config : :i18n
+        prefix == "I18n" ? :i18n : :config
       end
 
       # I18n::Railtie buffers app.config.i18n and applies it from

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -28,7 +28,7 @@ module RailsAiContext
 
       # @return [Hash] async workers, mailers, and channels
       def call
-        jobs = merge_unplaced(extract_jobs, extract_jobs_from_source)
+        jobs = merge_with_source(extract_jobs, extract_jobs_from_source)
 
         {
           jobs: jobs,
@@ -77,9 +77,13 @@ module RailsAiContext
           end
 
           queue = job.queue_name
-          # Reflection holds the Proc and nothing about it; the source says
-          # what it computes.
-          queue = (job_candidates.key?(job.name) && inherited_queue(job.name)) || COMPUTED_QUEUE if queue.is_a?(Proc)
+          # ActiveJob defaults queue_name to a lambda; any other Proc is a
+          # queue_as block, and only the source says what it computes.
+          if queue.equal?(ActiveJob::Base.queue_name)
+            queue = job.queue_name_from_part(nil)
+          elsif queue.is_a?(Proc)
+            queue = (job_candidates.key?(job.name) && inherited_queue(job.name)) || COMPUTED_QUEUE
+          end
 
           {
             name: job.name,
@@ -196,14 +200,16 @@ module RailsAiContext
         }.uniq
       end
 
-      # Reflection has no Resque job or PORO to walk: neither is an ActiveJob
-      # descendant. A name reflection did answer wins.
-      def merge_unplaced(reflected, from_source)
+      # Reflection answers the queue; the source answers what reflection cannot
+      # see: retries and signatures, and the Resque jobs, POROs and jobs in roots
+      # Zeitwerk never loads. On a name both answer, reflection wins.
+      def merge_with_source(reflected, from_source)
         return from_source if reflected.empty?
 
-        known = reflected.map { |job| job[:name] }
-        unplaced = from_source.select { |job| job[:unknown_base] && !known.include?(job[:name]) }
-        (reflected + unplaced).sort_by { |job| job[:name] }
+        sourced = from_source.index_by { |job| job[:name] }
+        merged = reflected.map { |job| (sourced.delete(job[:name]) || {}).except(:unknown_base).merge(job) }
+        bases = reflected_bases.map { |base| base[:name] }
+        (merged + sourced.values.reject { |job| bases.include?(job[:name]) }).sort_by { |job| job[:name] }
       end
 
       # `descendants` is every ActiveJob subclass in the process, and the name
@@ -491,6 +497,7 @@ module RailsAiContext
         # loaded until first delivery. Without this, .descendants is empty
         # and mailers are reported as absent.
         EagerLoad.dir(app.root, kind: "app/mailers")
+        load_mailers_outside_mailer_dirs
 
         ActionMailer::Base.descendants.filter_map do |mailer|
           # `descendants` is every mailer in the process, and a gem's is not
@@ -523,6 +530,13 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [], label: "extract_mailers")
       end
 
+      # A mailer in app/services or app/models loads only when something names it.
+      def load_mailers_outside_mailer_dirs
+        return if app.config.eager_load
+
+        EagerLoad.files(mailer_parent_files(SourceScan.paths(app.root, kind: "app/mailers").map(&:file).to_set))
+      end
+
       # The methods this mailer registers as action callbacks. A block filter
       # has no name to match, so only the symbol ones answer.
       def callback_filters(mailer)

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

@@ -24,6 +24,7 @@ module RailsAiContext
             type:          node.name.to_s,
             name:          name,
             computed_name: (true unless literal),
+            computed_foreign_key: (true if computed_key?(node)),
             # Sources, not literals: `class_name: Organisation.name` names a
             # class, and the marker names nothing.
             options:       scope_options(receiver_name(node)).merge(extract_keyword_sources(node)),
@@ -31,6 +32,17 @@ module RailsAiContext
             confidence:    confidence_for(node)
           }.compact
         end
+
+        private
+
+        # `foreign_key: AUTHOR_KEY` names a column only at run time.
+        def computed_key?(node)
+          key = extract_keyword_nodes(node)[:foreign_key]
+          return false if key.nil?
+
+          keys = key.is_a?(Prism::ArrayNode) ? key.elements : [ key ]
+          keys.empty? || keys.any? { |k| literal_string(k).nil? }
+        end
       end
     end
   end

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

@@ -6,6 +6,8 @@ module RailsAiContext
       # What a replay needs beyond the DSL listeners: down-only ranges (a revert
       # block is one), a block's `t.` statements, and four top-level statements.
       class MigrationReplayListener < BaseListener
+        include SchemaDslListener::TableBlock
+
         def on_def_node_enter(node)
           return unless node.name == :down
 
@@ -21,11 +23,17 @@ module RailsAiContext
         }.freeze
 
         def on_call_node_enter(node)
+          note_block(node)
           args = node.arguments&.arguments || []
           if %i[down revert].include?(node.name) && node.block
             @results << { kind: :down, range: node.location.start_line..node.location.end_line }
           elsif node.name == :column && block_column?(node.receiver)
             @results << column_definition(node, args)
+          elsif TABLE_OPS[node.name] == :remove_reference && block_column?(node.receiver)
+            # Table#remove_references drops each name it is given.
+            args.reject { |arg| arg.is_a?(Prism::KeywordHashNode) }.each do |arg|
+              @results << statement(node, :remove_reference, [ arg, *args.grep(Prism::KeywordHashNode) ]).merge(block: true)
+            end
           elsif TABLE_OPS.key?(node.name) && block_column?(node.receiver)
             @results << statement(node, TABLE_OPS[node.name], args).merge(block: true)
           elsif node.name == :create_join_table && (node.receiver.nil? || node.receiver.is_a?(Prism::LocalVariableReadNode))
@@ -97,7 +105,7 @@ module RailsAiContext
         # as a local variable or as a bare call.
         def block_column?(receiver)
           case receiver
-          when Prism::LocalVariableReadNode then receiver.name == :t
+          when Prism::LocalVariableReadNode then receiver.name == :t && table_param?(receiver)
           when Prism::CallNode then receiver.name == :t && receiver.receiver.nil?
           else false
           end

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

@@ -116,9 +116,9 @@ module RailsAiContext
 
         def prefixed_path(path)
           prefixes = @scopes.filter_map { |scope| scope[:prefix] }
-          return nil if prefixes.include?(:unknown)
-          return path if prefixes.empty? || path.nil?
+          return nil if path.nil? || prefixes.include?(:unknown)
 
+          # Rails' normalize_path gives every path its leading slash, prefixed or not.
           joined = "#{prefixes.join.chomp("/")}/#{path.to_s.delete_prefix("/")}"
           normalize_route_path(joined == "/" ? joined : joined.chomp("/"))
         end
@@ -167,8 +167,7 @@ module RailsAiContext
 
               key = extract_key(assoc.key)
               if key == :at
-                val = extract_value(assoc.value)
-                return val.is_a?(String) ? val : nil
+                return literal_path(assoc.value)
               end
             end
           end
@@ -181,14 +180,22 @@ module RailsAiContext
               next unless assoc.is_a?(Prism::AssocNode)
 
               if app_name(assoc.key)
-                val = extract_value(assoc.value)
-                return val.is_a?(String) ? val : nil
+                return literal_path(assoc.value)
               end
             end
           end
 
           nil
         end
+
+        # Only a string the source spells out: a constant or a call is a path
+        # nothing here can read, and an expression prints no path at all.
+        def literal_path(node)
+          return nil unless node.is_a?(Prism::StringNode) || node.is_a?(Prism::InterpolatedStringNode)
+
+          value = extract_value(node)
+          value == RailsAiContext::Confidence::INFERRED ? nil : value
+        end
       end
     end
   end

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

@@ -6,15 +6,51 @@ module RailsAiContext
       # Detects schema.rb DSL patterns via Prism AST:
       # create_table, t.string, t.index, add_foreign_key, create_enum
       class SchemaDslListener < BaseListener
+        # Whether a `t` receiver is a table: `Tag.find_each { |t| t.update! }` binds
+        # `t` to a record. A receiverless block is a table helper's, a def's `t` a helper's argument.
+        module TableBlock
+          TABLE_BLOCKS = %i[create_table change_table create_join_table].to_set.freeze
+
+          private
+
+          # The dispatcher enters a block's call before anything inside it.
+          def note_block(node)
+            params = node.block.is_a?(Prism::BlockNode) && node.block.parameters.is_a?(Prism::BlockParametersNode) &&
+                     node.block.parameters.parameters
+            return unless params
+
+            names = params.requireds.filter_map { |param| param.name if param.respond_to?(:name) }
+            table = node.receiver.nil? || TABLE_BLOCKS.include?(node.name)
+            (@blocks ||= []) << [ node.block.location, names, table ]
+          end
+
+          def table_param?(receiver)
+            offset = receiver.location.start_offset
+            _, _, table = Array(@blocks).reverse_each.find do |location, names, _|
+              names.include?(receiver.name) && offset.between?(location.start_offset, location.end_offset)
+            end
+            table.nil? || table
+          end
+        end
+
+        include TableBlock
+
+        # Each adapter's ColumnMethods (Rails 7.0 to 8.1), plus neighbor's vector types and PostGIS's.
         COLUMN_TYPES = %w[
-          string integer text boolean datetime date decimal float binary
-          references belongs_to jsonb json uuid bigint timestamp timestamptz time
-          inet cidr macaddr hstore ltree numrange tsrange daterange
-          bit bit_varying money oid xml point line lseg box path
-          polygon circle interval serial tsvector virtual primary_key
+          bigint binary boolean date datetime decimal float integer json string text time timestamp virtual
+          primary_key references belongs_to
+          bigserial bit bit_varying cidr citext daterange hstore inet interval int4range int8range jsonb ltree
+          macaddr money numrange oid point line lseg box path polygon circle serial tsrange tstzrange tsvector
+          uuid xml timestamptz enum
+          blob tinyblob mediumblob longblob tinytext mediumtext longtext
+          unsigned_integer unsigned_bigint unsigned_float unsigned_decimal
+          vector halfvec sparsevec cube
+          spatial geography geometry geometry_collection line_string multi_line_string multi_point
+          multi_polygon st_point st_polygon
         ].to_set.freeze
 
         def on_call_node_enter(node)
+          note_block(node)
           if node.receiver.nil?
             extract_top_level_call(node)
           elsif column_call?(node)
@@ -23,11 +59,28 @@ module RailsAiContext
             extract_index(node)
           elsif check_constraint_call?(node)
             extract_check_constraint(node)
+          elsif receiver_is_t?(node.receiver) && !read_elsewhere?(node.name)
+            unread_call(node)
           end
         end
 
+        # Block methods the replay reads, or that never add an index.
+        OTHER_TABLE_METHODS = %i[
+          column foreign_key remove_foreign_key remove_check_constraint rename_index
+          column_exists? index_exists? foreign_key_exists? check_constraint_exists?
+        ].to_set.freeze
+
         private
 
+        def read_elsewhere?(name)
+          OTHER_TABLE_METHODS.include?(name) || MigrationReplayListener::TABLE_OPS.key?(name)
+        end
+
+        # A block call no reader interprets may add an index or a column.
+        def unread_call(node)
+          @results << { type: :unread_call, name: node.name.to_s, location: node.location.start_line }
+        end
+
         def extract_top_level_call(node)
           case node.name
           when :create_table
@@ -161,33 +214,36 @@ module RailsAiContext
           when Prism::CallNode
             receiver.name == :t && receiver.receiver.nil?
           when Prism::LocalVariableReadNode
-            receiver.name == :t
+            receiver.name == :t && table_param?(receiver)
           else
             false
           end
         end
 
+        # `t.references :a, :b` defines each name; primary_key's second argument is its type.
         def extract_column(node)
-          args = node.arguments&.arguments || []
-          name_arg = args.first
-          return unless name_arg.is_a?(Prism::StringNode) || name_arg.is_a?(Prism::SymbolNode)
-
-          col_name = literal_string(name_arg)
-
-          options = extract_keyword_options(node)
+          # `t.string "name", { limit: 50 }` passes its options braced.
+          braced, positional = (node.arguments&.arguments || []).reject { |arg| arg.is_a?(Prism::KeywordHashNode) }
+                                                                 .partition { |arg| arg.is_a?(Prism::HashNode) }
+          positional = positional.first(1) if node.name == :primary_key
+          names = positional.map { |arg| literal_string(arg) }
+          return unread_call(node) if names.empty? || names.any?(&:nil?)
 
-          @results << {
-            type:        :column,
-            table:       nil,
-            column_type: node.name.to_s,
-            name:        col_name,
-            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),
-            location:    node.location.start_line
-          }
+          options = braced.map { |hash| hash_node_to_hash(hash) }.reduce(extract_keyword_options(node), :merge)
+          names.each do |col_name|
+            @results << {
+              type:        :column,
+              table:       nil,
+              column_type: node.name.to_s,
+              name:        col_name,
+              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),
+              location:    node.location.start_line
+            }
+          end
         end
 
         def extract_index(node)

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

@@ -7,16 +7,53 @@ module RailsAiContext
       # this tracks the open blocks for `in_scope?` and `scope_options`.
       module WithOptionsScope
         UNNAMED_BLOCK_PARAM = :"*"
+        UNCERTAIN_BLOCK = Object.new.freeze
+        # Zero-arity blocks these run on the class itself, state_machines' and aasm's included;
+        # any other such block may be evaluated on another object (`has_details_table do`, `Menu.define do`).
+        OWN_BLOCKS = %i[with_options included prepended class_methods concerning state_machine state event aasm].to_set.freeze
+        EVALS = %i[class_eval class_exec module_eval module_exec instance_eval instance_exec].to_set.freeze
 
         def self.included(base)
           base.prepend(Dispatch)
         end
 
+        # Whether a block's declarations may belong to another object: it takes no parameters and
+        # its call is neither a known one nor an eval on the class. The block answers whether a
+        # local names an open mixin hook's class.
+        def self.uncertain_block?(node)
+          block = node.block
+          return false unless block.is_a?(Prism::BlockNode) && block.parameters.nil?
+          return !(OWN_BLOCKS.include?(node.name) || EVALS.include?(node.name)) if node.receiver.nil?
+
+          receiver = node.receiver
+          if EVALS.include?(node.name)
+            own = receiver.is_a?(Prism::SelfNode) || (receiver.is_a?(Prism::LocalVariableReadNode) && block_given? && yield(receiver.name))
+            return !own
+          end
+
+          # `Menu.define do`, `Class.new do`: a constant's DSL block; `[1].each {}` yields.
+          receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+        end
+
+        # `base` in `def self.included(base)`: the class every includer is.
+        def self.hook_param(node)
+          return unless node.receiver.is_a?(Prism::SelfNode) && ConcernMembership::MIXIN_HOOKS.include?(node.name.to_s)
+
+          first = node.parameters&.requireds&.first
+          first.name if first.respond_to?(:name)
+        end
+
         # Prepended, so the listener's own handler never sees the call that
         # opened the scope and no listener repeats the guard.
         module Dispatch
           def on_call_node_enter(node)
-            with_options_block?(node) ? enter_scope(node) : super
+            return enter_scope(node) if with_options_block?(node)
+
+            count = @results.size
+            super
+            # Kept, and marked so a schema check does not judge them against this class's table.
+            @results.drop(count).each { |result| result[:scope_uncertain] = true } if uncertain_scope?
+            @scopes.push({ node: node, param: UNCERTAIN_BLOCK, options: {} }) if uncertain_block?(node)
           end
 
           # `super` where the listener has its own leave hook: swallowing it
@@ -29,7 +66,8 @@ module RailsAiContext
           # `base.has_many` inside `def self.included(base)` declares on every includer,
           # as a `with_options` block's parameter does.
           def on_def_node_enter(node)
-            @scopes.push({ node: node, param: hook_param(node), options: {} }) if mixin_hook?(node)
+            param = WithOptionsScope.hook_param(node)
+            @scopes.push({ node: node, param: param, options: {} }) if param
             super if defined?(super)
           end
 
@@ -46,15 +84,6 @@ module RailsAiContext
 
         private
 
-        def mixin_hook?(node)
-          node.receiver.is_a?(Prism::SelfNode) && ConcernMembership::MIXIN_HOOKS.include?(node.name.to_s) && hook_param(node)
-        end
-
-        def hook_param(node)
-          first = node.parameters&.requireds&.first
-          first.name if first.respond_to?(:name)
-        end
-
         def with_options_block?(node)
           node.name == :with_options && node.block
         end
@@ -66,7 +95,15 @@ module RailsAiContext
         end
 
         def leave_scope(node)
-          @scopes.pop if with_options_block?(node) && @scopes.last&.fetch(:node)&.equal?(node)
+          @scopes.pop if @scopes.last&.fetch(:node)&.equal?(node)
+        end
+
+        def uncertain_block?(node)
+          WithOptionsScope.uncertain_block?(node) { |name| enclosing_scope(name) }
+        end
+
+        def uncertain_scope?
+          @scopes.any? { |scope| scope[:param].equal?(UNCERTAIN_BLOCK) }
         end
 
         # A macro this listener should read: receiverless, or sent to the

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

@@ -262,12 +262,27 @@ module RailsAiContext
             tables[table][:columns].reject! { |c| c[:name] == col[:name] }
             tables[table][:columns] << col
           end
+          add_reference_foreign_key(tables[table], table, name, options || {})
           return unless ref[:index]
 
           tables[table][:indexes].reject! { |idx| idx[:name] == ref[:index][:name] }
           tables[table][:indexes] << ref[:index]
         end
 
+        # ReferenceDefinition's foreign_key: (7.0 to 8.1): true points at the
+        # pluralized name, a hash may name to_table: and primary_key:.
+        def add_reference_foreign_key(table_data, table, name, options)
+          fk = options[:foreign_key]
+          return if !fk || options[:polymorphic]
+
+          fk = {} unless fk.is_a?(Hash)
+          to = fk[:to_table] || name.to_s.pluralize
+          return if to == RailsAiContext::Confidence::INFERRED
+
+          (table_data[:foreign_keys] ||= []) <<
+            SchemaConventions.foreign_key_entry(table, to.to_s, SchemaConventions.reference_column_name(name), fk[:primary_key])
+        end
+
         def apply_schema_index(entry, current_table, tables)
           return unless tables[current_table]
           cols = entry[:columns]&.map(&:to_s) || []

data/lib/rails_ai_context/introspectors/migration_replay.rb

@@ -211,6 +211,8 @@ module RailsAiContext
             Statements.apply_schema_column(entry, current_table, tables, pk_type)
           elsif entry[:type] == :index && current_table
             Statements.apply_schema_index(entry, current_table, tables)
+          elsif entry[:type] == :unread_call && current_table
+            SchemaConventions.note_unread_call(tables[current_table], entry[:name])
           end
         end
       end