rails-ai-context 5.21.1 → 5.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35ff190a8ba7d3cad8db797b62b37d14595317f0fbb496de79d68a05e31791f2
-  data.tar.gz: a22572911254cd6ede2927a8833ac8c499ae5a3aee615825daaaa50451a59bf6
+  metadata.gz: 8afb263c0004a822a803eee097300e87dcb5a3a2de27d996a3cc5f11ea801051
+  data.tar.gz: 462a8ca8d7f4a66cd617af71322356908f513aa88ac7aec2046f32cf4279805f
 SHA512:
-  metadata.gz: c5afe25035b7a14ba9ed34961a9701c47e5b3f26909c7916514184123cdb1154482769ea018e751b84f5eed71ab4a1bca175a4d22b3e51bf1fccad9fa118e8ae
-  data.tar.gz: e3973d85c3b0be6dad49ee33f3d918bf9b228e481f600c0435db06ae65a42596d6cc61b968b67b95b01b78bfc35e3c4d43843c8115efca7c00b9278ef8e26d5a
+  metadata.gz: 2f48e61abb15f942c9a3b41eced790ce41618f091e337d84c1d598486e74e3a58e3331c9acf971ad2fea0d0a0bb8a909caef4c6b9fd3196fba51dbe318532e97
+  data.tar.gz: 07e4b2759758da12d51805c0861e8a101fcdefdff55cba0db7714c6464473e486842fbd93c55b6480c8ce7b87325138fa18eb0920c38e219f0df3556a1ec0b19

data/CHANGELOG.md

@@ -5,6 +5,60 @@ 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.21.3] - 2026-08-12
+
+### Fixed
+
+- **Foreign keys name the column that was declared, not one invented from the
+  target table.** `add_foreign_key "accounts", "accounts", column:
+  "moved_to_account_id"` was reported as `account_id`, a column the table does
+  not have, and two such keys on one table collided into the same invented
+  name. The schema listener dropped `column:`/`primary_key:` entirely, so the
+  convention was the only answer; it is now the fallback for the case Rails
+  omits the option in. The migration-replay path invented `statuse_id` from
+  `statuses` for the same reason. (#140)
+- **A service's constructor is read from the service, not from the first
+  nested class in the file.** `rails_get_service_pattern` matched the first
+  `def initialize(` anywhere in the source, so a nested error class or query
+  builder supplied the signature for a service that defines no constructor,
+  and an agent reading it wrote `PostStatusService.new(message, accounts)` for
+  a class whose real interface is `.new.call(...)`. The constructor now comes
+  from the AST walk that already resolves the interface owner, and a
+  parenthesis-less `def initialize` is no longer missed. (#141)
+- **Autoloader root_dirs are gem-relative, like initializer sources.** #139
+  fixed the sources and left `autoload.autoloaders[].root_dirs`, where every
+  engine's paths land, still absolute in `.ai-context.json`. Both introspectors
+  now share one `PortablePath`, which also collapses a gem the Gemfile takes
+  from `path:` or `git:`. A guard spec walks the whole generated context for
+  paths from the generating machine. (#142)
+- **A model's `*_url` and `*_path` columns are not reported as missing route
+  helpers.** `rails_validate` read every receiverless call ending in `_url` as
+  a route helper, and an attribute reader has no `def` for the local-method
+  escape to find, so `shared_inbox_url` on Mastodon's `accounts` warned as a
+  broken route. The check now consults the model's own column list. (#143)
+
+## [5.21.2] - 2026-08-12
+
+### Fixed
+
+- **The static tier no longer drops a model's concerns.** Nothing in the
+  listener stack collected `include`/`prepend`, so `rails_get_model_details`
+  answered `--no-boot` with no Concerns section at all - not even an
+  `[UNAVAILABLE]` marker - for a model that includes one. A new
+  `MixinsListener` reads them from the source, filtered to the mixins
+  reflection would report so both tiers answer the same question. (#137)
+- **Cookie settings that Rails computes per request are named, not
+  inspected.** Rails 8 defaults `same_site` to a lambda, which reached
+  `.ai-context.json` as `#<Proc:0x...>` - an address that answers nothing and
+  moves on every boot, so the file was rewritten on every run even when the app
+  had not changed. Callables now render `[UNAVAILABLE: computed at request
+  time]`, nested ones included. (#138)
+- **Initializer sources are gem-relative instead of absolute machine paths.**
+  Every one of them was written into `.ai-context.json` as
+  `/Users/<name>/.rvm/gems/ruby-3.4.9/gems/railties-8.0.5.1/...`, which is
+  wrong on every other machine, wrong again after a Ruby upgrade, and carries
+  the generating developer's home directory into the app's repository. (#139)
+
 ## [5.21.1] - 2026-08-12
 
 ### Fixed

data/CONTEXT.md

@@ -20,6 +20,14 @@ Avoid "format" for either sense - claude is not a file format, and the word coll
 
 `Install::AiTool` is the one table of what each means: name, context files, MCP config shape, legacy leftovers. `Install::SelectionRecord` owns which ones the user picked - written to YAML always and to the initializer line inside a Rails app, read initializer-first because that is the file a user hand-edits.
 
+## Path
+
+Two senses, one per module, and neither is bare "path" in a name.
+
+**Where code lives** - `PathResolver` answers which directories a kind of app code can occupy for a given root: conventional layout, packwerk packs, in-repo engines, configured extras.
+
+**How a path is written down** - `PortablePath` rewrites one so it means the same thing on another machine, because what it touches ends up in `.ai-context.json` and the app commits that file. App paths go app-relative, gem paths keep the gem and version and drop the install prefix. "Relativize" always means this.
+
 ## Static tier
 
 The mode where the app did not boot, or `--no-boot` was passed. What an introspector answers here is what it declared, never what a runtime check happened to detect. Every introspector in `INTROSPECTOR_MAP` extends `StaticTier` and names one of three kinds:

data/docs/INTROSPECTORS.md

@@ -184,7 +184,8 @@ It runs a single-pass Dispatcher that walks the AST once and feeds events to all
 | EnumsListener | Rails 7+ and legacy enum syntax, prefix/suffix options |
 | CallbacksListener | All AR callback types, `after_commit` with `on:` resolution |
 | MacrosListener | `encrypts`, `normalizes`, `delegate`, `has_secure_password`, `serialize`, `store`, `has_one_attached`, `has_many_attached`, `has_rich_text`, `generates_token_for`, `attribute` |
-| MethodsListener | `def`/`def self.`, visibility tracking, parameter extraction, `class << self` |
+| MethodsListener | `def`/`def self.`, visibility tracking, parameter extraction, `class << self`; `include_initialize: true` adds the constructor a caller reports on its own |
+| MixinsListener | `include`, `prepend`, `extend`, flagging the ones that reach the ancestor chain |
 
 ### The targeted-walk listeners
 

data/lib/rails_ai_context/introspectors/autoload_introspector.rb

@@ -136,12 +136,10 @@ module RailsAiContext
         "#{hit[:method]}: #{values.first}"
       end
 
-      # Rails lists a path once per railtie that contributed it.
+      # Rails lists a path once per railtie that contributed it, and every
+      # engine's paths sit under the machine's gem prefix rather than the app.
       def relativize(paths)
-        Array(paths).map { |p|
-          s = p.to_s
-          s.start_with?(root) ? s.sub("#{root}/", "") : s
-        }.uniq
+        PortablePath.relativize_all(paths, root)
       end
     end
   end

data/lib/rails_ai_context/introspectors/initializer_introspector.rb

@@ -110,8 +110,7 @@ module RailsAiContext
         return nil unless loc
 
         path, line = loc
-        path = path.sub("#{root}/", "") if path.start_with?(root)
-        "#{path}:#{line}"
+        "#{PortablePath.relativize(path, root)}:#{line}"
       rescue => e
         $stderr.puts "[rails-ai-context] block_source_location failed: #{e.message}" if ENV["DEBUG"]
         nil

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

@@ -8,8 +8,11 @@ module RailsAiContext
       # visibility modifier calls, including inline forms like
       # `private :method_name`.
       class MethodsListener < BaseListener
-        def initialize
-          super
+        # A constructor is not part of the callable interface every other
+        # caller asks for, so it stays out unless one asks for it by name.
+        def initialize(include_initialize: false)
+          super()
+          @include_initialize = include_initialize
           @visibility_stack = [ :public ]
           @in_singleton_class = false
           @singleton_depth = 0
@@ -84,8 +87,7 @@ module RailsAiContext
           is_class_method = @in_singleton_class || node.receiver&.is_a?(Prism::SelfNode)
           method_name = node.name.to_s
 
-          # Skip initialize for instance methods
-          return if method_name == "initialize" && !is_class_method
+          return if method_name == "initialize" && !is_class_method && !@include_initialize
 
           # Inline visibility (`private :foo`) takes precedence over positional
           visibility = @inline_visibility_stack.last[method_name] || @visibility_stack.last

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # Detects `include`, `prepend` and `extend` with a constant argument.
+      #
+      # `ancestor` marks the ones that reach the ancestor chain, which is what
+      # reflection reports - so a caller can answer the same question the
+      # booted tier answers.
+      class MixinsListener < BaseListener
+        MIXIN_MACROS = %i[include prepend extend].to_set.freeze
+        ANCESTOR_MACROS = %i[include prepend].to_set.freeze
+
+        def initialize
+          super
+          @singleton_depth = 0
+        end
+
+        # `include` inside `class << self` lands on the singleton class, so it
+        # never reaches `ancestors` - extend semantics wearing an include's name.
+        def on_singleton_class_node_enter(_node)
+          @singleton_depth += 1
+        end
+
+        def on_singleton_class_node_leave(_node)
+          @singleton_depth -= 1
+        end
+
+        def on_call_node_enter(node)
+          return unless node.receiver.nil?
+          return unless MIXIN_MACROS.include?(node.name)
+
+          (node.arguments&.arguments || []).each do |arg|
+            name = constant_name(arg)
+            next unless name
+
+            @results << {
+              macro:      node.name,
+              name:       name,
+              ancestor:   @singleton_depth.zero? && ANCESTOR_MACROS.include?(node.name),
+              location:   node.location.start_line,
+              confidence: confidence_for(node)
+            }
+          end
+        end
+
+        private
+
+        def constant_name(node)
+          return unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+          extract_value(node)
+        end
+      end
+    end
+  end
+end

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

@@ -64,12 +64,18 @@ module RailsAiContext
           to_arg = args[1]
           return unless from_arg.is_a?(Prism::StringNode) && to_arg.is_a?(Prism::StringNode)
 
+          options = extract_keyword_options(node)
+
           @results << {
-            type:     :foreign_key,
-            from:     from_arg.unescaped,
-            to:       to_arg.unescaped,
-            location: node.location.start_line
-          }
+            type:        :foreign_key,
+            from:        from_arg.unescaped,
+            to:          to_arg.unescaped,
+            # Absent means the Rails convention holds; naming it here would
+            # make a declared column indistinguishable from a guessed one.
+            column:      options[:column]&.to_s,
+            primary_key: options[:primary_key]&.to_s,
+            location:    node.location.start_line
+          }.compact
         end
 
         def extract_enum(node)

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -591,11 +591,23 @@ module RailsAiContext
           # with callbacks found" and then raised a TypeError on a Hash lookup
           # against an Array.
           callbacks: group_callbacks_by_type(data[:callbacks]),
+          concerns: static_concerns(data[:mixins]),
           macros: data[:macros],
           methods: data[:methods]
         }
       end
 
+      # Only the mixins reflection would report, so both tiers answer the same
+      # question. This sees the model file alone, where the booted tier also
+      # walks what its superclass and its concerns pulled in.
+      def static_concerns(mixins)
+        (mixins || [])
+          .select { |mixin| mixin[:ancestor] }
+          .map { |mixin| mixin[:name] }
+          .reject { |name| framework_concern?(name) }
+          .uniq
+      end
+
       # Mongoid documents are invisible to ActiveRecord reflection, so both
       # tiers parse them from source. Fields and embedded relations come from
       # the Mongoid listener; shared-name macros (belongs_to, has_many,

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -298,6 +298,17 @@ module RailsAiContext
         entry
       end
 
+      # Rails omits column:/primary_key: only where the convention holds, so
+      # the fallback is what was declared rather than a guess. Both dump
+      # readers land here so the convention lives in one place.
+      def foreign_key_entry(from, to, column, primary_key)
+        {
+          from_table: from, to_table: to,
+          column: column&.to_s || "#{to.to_s.singularize}_id",
+          primary_key: primary_key&.to_s || "id"
+        }
+      end
+
       def static_index(index)
         columns = index[:columns]
         return nil if columns.empty?
@@ -330,12 +341,9 @@ module RailsAiContext
         end
 
         schema.foreign_keys.each do |fk|
-          # SchemaDslListener doesn't capture column/primary_key options for
-          # add_foreign_key; fall back to convention.
-          tables[fk[:from]]&.dig(:foreign_keys)&.push({
-            from_table: fk[:from], to_table: fk[:to],
-            column: "#{fk[:to].singularize}_id", primary_key: "id"
-          })
+          tables[fk[:from]]&.dig(:foreign_keys)&.push(
+            foreign_key_entry(fk[:from], fk[:to], fk[:column], fk[:primary_key])
+          )
         end
 
         check_constraints = schema.check_constraints
@@ -815,8 +823,7 @@ module RailsAiContext
           to = entry[:to_table]
           return unless tables[from]
           opts = entry[:options] || {}
-          column = opts[:column]&.to_s || "#{to&.to_s&.chomp('s')}_id"
-          tables[from][:foreign_keys] << { from_table: from, to_table: to, column: column, primary_key: "id" }
+          tables[from][:foreign_keys] << foreign_key_entry(from, to, opts[:column], opts[:primary_key])
         end
       end
 

data/lib/rails_ai_context/introspectors/schema_reader.rb

@@ -117,7 +117,10 @@ module RailsAiContext
         when :add_index
           schema[:tables][event[:table]]&.dig(:indexes)&.push(index_entry(event))
         when :foreign_key
-          schema[:foreign_keys] << { from: event[:from], to: event[:to] }
+          schema[:foreign_keys] << {
+            from: event[:from], to: event[:to],
+            column: event[:column], primary_key: event[:primary_key]
+          }.compact
         when :enum
           schema[:enums] << { name: event[:name], values: event[:values] }
         when :check_constraint

data/lib/rails_ai_context/introspectors/security_introspector.rb

@@ -246,11 +246,17 @@ module RailsAiContext
         {}
       end
 
+      # Rails 8 defaults same_site to a lambda. Left alone it reaches
+      # .ai-context.json as an address that answers nothing and moves every
+      # boot, so the file is rewritten on every run. Nested one level down it
+      # is worse: the encoder renders it `{}`, which reads as a setting the app
+      # left empty.
       def serializable(value)
         case value
         when Symbol then value.to_s
-        when Hash then value.transform_keys(&:to_s)
-        when Array then value.map(&:to_s)
+        when Hash then value.each_with_object({}) { |(key, nested), result| result[key.to_s] = serializable(nested) }
+        when Array then value.map { |nested| serializable(nested) }
+        when Proc then Confidence.unavailable("computed at request time")
         else value
         end
       end

data/lib/rails_ai_context/introspectors/source_introspector.rb

@@ -20,7 +20,8 @@ module RailsAiContext
         enums:        Listeners::EnumsListener,
         callbacks:    Listeners::CallbacksListener,
         macros:       Listeners::MacrosListener,
-        methods:      Listeners::MethodsListener
+        methods:      Listeners::MethodsListener,
+        mixins:       Listeners::MixinsListener
       }.freeze
 
       # Introspect a file on disk (cached parse) with default listeners.

data/lib/rails_ai_context/portable_path.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Rewrites a path so it means the same thing on another machine. What is
+  # generated here ends up in .ai-context.json, which the app commits: an
+  # absolute path is wrong on every other checkout, wrong again after a Ruby
+  # or gem upgrade, and it carries the generating developer's home directory
+  # into the repository. App paths go app-relative; gem paths keep the gem
+  # and version and drop the install prefix.
+  #
+  # Distinct from PathResolver, which answers where a kind of app code lives.
+  module PortablePath
+    module_function
+
+    def relativize(path, root)
+      path = path.to_s
+      root = root.to_s
+      return path.delete_prefix("#{root}/") if !root.empty? && path.start_with?("#{root}/")
+
+      gem_roots.each do |gem_root|
+        return path.delete_prefix(gem_root) if path.start_with?(gem_root)
+      end
+
+      gem_checkouts.each do |dir, name|
+        return File.join(name, path.delete_prefix(dir)) if path.start_with?(dir)
+      end
+      path
+    end
+
+    def relativize_all(paths, root)
+      Array(paths).map { |path| relativize(path, root) }.uniq
+    end
+
+    # Every prefix a gem can be unpacked under, trailing separator included so
+    # a prefix cannot match a sibling directory that merely starts the same.
+    def gem_roots
+      @gem_roots ||= (Gem.path + [ Gem.default_dir ]).compact.uniq
+        .map { |dir| File.join(dir, "gems") + File::SEPARATOR }
+    end
+
+    # A gem the Gemfile takes from path: or git: is never unpacked under a
+    # gem root, so its own checkout is the only prefix that names it. Longest
+    # first, because one checkout can sit inside another.
+    def gem_checkouts
+      @gem_checkouts ||= Gem.loaded_specs.each_value.filter_map { |spec|
+        dir = spec.full_gem_path.to_s
+        next if dir.empty? || gem_roots.any? { |gem_root| dir.start_with?(gem_root) }
+        [ dir + File::SEPARATOR, spec.full_name ]
+      }.sort_by { |dir, _name| -dir.length }
+    rescue => e
+      $stderr.puts "[rails-ai-context] PortablePath.gem_checkouts failed: #{e.message}" if ENV["DEBUG"]
+      []
+    end
+  end
+end

data/lib/rails_ai_context/tools/get_service_pattern.rb

@@ -81,12 +81,14 @@ module RailsAiContext
         lines = [ "# #{class_name}", "" ]
         lines << "**File:** `#{relative}` (#{count_phrase(line_count, "line")})"
 
+        owned = owned_methods(source, constant_for(file, services_dir))
+
         # Initialize params
-        init_params = extract_initialize_params(source)
+        init_params = extract_initialize_params(owned)
         lines << "**Initialize:** `#{init_params}`" if init_params
 
         # Public methods
-        public_methods = extract_public_methods(source, constant_for(file, services_dir))
+        public_methods = extract_public_methods(owned)
         if public_methods.any?
           lines << "" << "## Public Methods"
           public_methods.each { |m| lines << "- `#{m}`" }
@@ -139,20 +141,23 @@ module RailsAiContext
           relative = file.sub("#{root}/", "")
           class_name = extract_class_name(source) || File.basename(file, ".rb").camelize
           line_count = source.lines.size
-          public_methods = extract_public_methods(source, constant_for(file, services_dir))
+          owned = owned_methods(source, constant_for(file, services_dir))
+          public_methods = extract_public_methods(owned)
+          init_params = extract_initialize_params(owned)
 
           pattern_stats[:total] += 1
-          has_initialize = source.match?(/def initialize/)
+          has_initialize = !init_params.nil?
           pattern_stats[:initialize_call] += 1 if has_initialize && public_methods.any? { |m| m.start_with?("call") }
           pattern_stats[:initialize_single_method] += 1 if has_initialize && public_methods.size == 1
-          pattern_stats[:class_method_call] += 1 if source.match?(/def self\.call/)
+          pattern_stats[:class_method_call] += 1 if owned.any? { |m| m[:scope] == :class && m[:name] == "call" }
           pattern_stats[:result_object] += 1 if source.match?(/Result\.new|OpenStruct\.new|Struct\.new|\.success|\.failure/)
 
           service_data << {
             file: relative,
             class_name: class_name,
             line_count: line_count,
-            public_methods: public_methods
+            public_methods: public_methods,
+            init_params: init_params
           }
         end
 
@@ -183,13 +188,12 @@ module RailsAiContext
             methods_str = s[:public_methods].any? ? s[:public_methods].join(", ") : "none"
             lines << "- **Methods:** #{methods_str}"
 
+            lines << "- **Initialize:** `#{s[:init_params]}`" if s[:init_params]
+
             # Read source for additional detail
             full_path = File.join(root, s[:file])
             source = safe_read(full_path)
             if source
-              init_params = extract_initialize_params(source)
-              lines << "- **Initialize:** `#{init_params}`" if init_params
-
               side_effects = extract_side_effects(source)
               lines << "- **Side effects:** #{side_effects.join(', ')}" if side_effects.any?
 
@@ -216,17 +220,11 @@ module RailsAiContext
         match[1] if match
       end
 
-      private_class_method def self.extract_initialize_params(source)
-        match = source.match(/def initialize\(([^)]*)\)/m)
-        return nil unless match
-        "initialize(#{match[1].strip})"
-      end
-
-      # A service's interface is the public methods of the service class
-      # itself. Nesting a query builder or a set of condition objects inside
-      # the service that uses them is a normal way to organise a large one, and
-      # a line scan cannot see that: it reported the nested class's first `def`
-      # as the entry point, and a `private` inside a nested class hid the real
+      # The methods the service class defines itself. Nesting a query builder
+      # or a set of condition objects inside the service that uses them is a
+      # normal way to organise a large one, and a line scan cannot see that:
+      # it reported the nested class's first `def` as the entry point, its
+      # constructor as the service's, and a `private` inside it hid the real
       # `call` that followed the nested class's `end`.
       #
       # `expected_constant` comes from the path rather than the source, the way
@@ -234,22 +232,36 @@ module RailsAiContext
       # and only the path carries the namespace. A file that does not follow
       # the convention falls back to the shallowest nesting, which is the
       # outermost definition in the file.
-      private_class_method def self.extract_public_methods(source, expected_constant = nil)
+      #
+      # One walk per file: the interface and the constructor have to resolve
+      # the same owner, and a second walk could pick a different one.
+      private_class_method def self.owned_methods(source, expected_constant = nil)
         ast = Introspectors::SourceIntrospector.walk_source(
-          source, { methods: Introspectors::Listeners::MethodsListener }
+          source, { methods: -> { Introspectors::Listeners::MethodsListener.new(include_initialize: true) } }
         )
         methods = ast[:methods] || []
         return [] if methods.empty?
 
         owner = primary_owner(methods, expected_constant)
-
-        methods.select { |m| m[:visibility] == :public && m[:owner].join("::") == owner }
-               .map { |m| m[:signature] }
+        methods.select { |m| m[:owner].join("::") == owner }
       rescue => e
-        $stderr.puts "[rails-ai-context] extract_public_methods AST failed: #{e.message}" if ENV["DEBUG"]
+        $stderr.puts "[rails-ai-context] owned_methods AST failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
+      # A service that defines no constructor answers `.new` with no arguments.
+      private_class_method def self.extract_initialize_params(owned)
+        ctor = owned.find { |m| m[:name] == "initialize" && m[:scope] == :instance }
+        ctor && ctor[:signature]
+      end
+
+      # The constructor is reported on its own line, not as part of the
+      # interface, which is why it is dropped here rather than at the walk.
+      private_class_method def self.extract_public_methods(owned)
+        owned.select { |m| m[:visibility] == :public && m[:name] != "initialize" }
+             .map { |m| m[:signature] }
+      end
+
       private_class_method def self.primary_owner(methods, expected_constant)
         owners = methods.map { |m| m[:owner].join("::") }
         return expected_constant if expected_constant && owners.include?(expected_constant)

data/lib/rails_ai_context/tools/validate_semantics.rb

@@ -203,23 +203,23 @@ module RailsAiContext
         if file.end_with?(".html.erb", ".erb")
           if visitor
             warnings.concat(check_partial_existence_ast(file, visitor))
-            warnings.concat(check_route_helpers_ast(visitor, context))
+            warnings.concat(check_route_helpers_ast(file, visitor, context))
           else
             warnings.concat(check_partial_existence_regex(file, content))
-            warnings.concat(check_route_helpers_regex(content, context))
+            warnings.concat(check_route_helpers_regex(file, content, context))
           end
           warnings.concat(check_stimulus_controllers(content, context))
           warnings.concat(check_instance_variable_usage(file, content, context))
           warnings.concat(check_respond_to_template_existence(file, content))
         elsif file.end_with?(".rb")
           if visitor
-            warnings.concat(check_route_helpers_ast(visitor, context))
+            warnings.concat(check_route_helpers_ast(file, visitor, context))
             warnings.concat(check_partial_existence_ast(file, visitor, qualified_only: true))
             warnings.concat(check_column_references_ast(file, visitor, context))
             warnings.concat(check_strong_params_ast(file, visitor, context))
             warnings.concat(check_callback_existence_ast(file, visitor, context))
           else
-            warnings.concat(check_route_helpers_regex(content, context))
+            warnings.concat(check_route_helpers_regex(file, content, context))
             warnings.concat(check_column_references_regex(file, content, context))
           end
           # Cache-only checks (no AST needed)
@@ -313,19 +313,22 @@ module RailsAiContext
       ASSET_HELPER_PREFIXES = %w[image asset font stylesheet javascript audio video file compute_asset auto_discovery_link favicon].freeze
       DEVISE_HELPER_NAMES = %w[session registration password confirmation unlock omniauth_callback user_session user_registration user_password user_confirmation user_unlock].freeze
 
-      private_class_method def self.check_route_helpers_ast(visitor, context)
+      private_class_method def self.check_route_helpers_ast(file, visitor, context)
         warnings = []
         routes = context[:routes]
         return warnings unless routes && routes[:by_controller]
         valid_names = build_route_name_set(routes)
         return warnings if valid_names.empty?
 
+        columns = helper_shaped_columns(file, context)
+
         seen = Set.new
         visitor.route_helper_calls.each do |call|
           helper = call[:name]
           next if seen.include?(helper)
           seen << helper
           next if visitor.local_route_method_defined?(helper, call[:scope], call[:method_kind])
+          next if columns.include?(helper)
 
           name = helper.sub(/_(path|url)\z/, "")
           next if ASSET_HELPER_PREFIXES.any? { |p| name.start_with?(p) }
@@ -338,13 +341,15 @@ module RailsAiContext
       end
 
       # Regex fallback
-      private_class_method def self.check_route_helpers_regex(content, context)
+      private_class_method def self.check_route_helpers_regex(file, content, context)
         warnings = []
         routes = context[:routes]
         return warnings unless routes && routes[:by_controller]
         valid_names = build_route_name_set(routes)
         return warnings if valid_names.empty?
 
+        columns = helper_shaped_columns(file, context)
+
         seen = Set.new
         local_method_names = local_route_like_method_names(content)
         content.scan(/\b(\w+)_(path|url)\b/).each do |match|
@@ -353,6 +358,7 @@ module RailsAiContext
           next if seen.include?(helper)
           seen << helper
           next if local_method_names.include?(helper)
+          next if columns.include?(helper)
           next if ASSET_HELPER_PREFIXES.any? { |p| name.start_with?(p) }
           next if DEVISE_HELPER_NAMES.include?(name)
           next if %w[edit new polymorphic].include?(name)
@@ -361,6 +367,18 @@ module RailsAiContext
         warnings
       end
 
+      # A column named `shared_inbox_url` reads as a receiverless call to a
+      # route helper, and the attribute reader it resolves to has no `def`
+      # anywhere to find it by. Columns only: an association named like a
+      # helper is not a reader, and suppressing on it would hide a real
+      # missing route.
+      private_class_method def self.helper_shaped_columns(file, context)
+        valid = model_valid_columns(file, context)
+        return Set.new unless valid
+
+        valid[:table_columns].select { |c| c.to_s.end_with?("_path", "_url") }.to_set
+      end
+
       private_class_method def self.local_route_like_method_names(content)
         content.scan(/^\s*(?:(?:private|protected|public|private_class_method)\s+)*def\s+(?:self\.)?(\w+_(?:path|url))\b/).flatten.to_set
       end
@@ -432,14 +450,16 @@ module RailsAiContext
         table_data = schema[:tables] && schema[:tables][table_name]
         return nil unless table_data
 
-        columns = Set.new
-        table_data[:columns]&.each { |c| columns << c[:name] }
+        table_columns = Set.new
+        table_data[:columns]&.each { |c| table_columns << c[:name] }
+
+        columns = table_columns.dup
         model_data[:associations]&.each do |a|
           columns << a[:name] if a[:name]
           columns << a[:foreign_key] if a[:foreign_key]
         end
 
-        { columns: columns, table: table_name, model: model_name, model_data: model_data }
+        { columns: columns, table_columns: table_columns, table: table_name, model: model_name, model_data: model_data }
       end
 
       # ── CHECK 4: Strong params vs schema (AST) ───────────────────────

data/lib/rails_ai_context/version.rb

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

data/server.json

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.21.1
+  version: 5.21.3
 platform: ruby
 authors:
 - crisnahine
@@ -345,6 +345,7 @@ files:
 - lib/rails_ai_context/introspectors/listeners/methods_listener.rb
 - lib/rails_ai_context/introspectors/listeners/middleware_config_listener.rb
 - lib/rails_ai_context/introspectors/listeners/migration_dsl_listener.rb
+- lib/rails_ai_context/introspectors/listeners/mixins_listener.rb
 - lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb
 - lib/rails_ai_context/introspectors/listeners/mongoid_fields_listener.rb
 - lib/rails_ai_context/introspectors/listeners/mount_listener.rb
@@ -383,6 +384,7 @@ files:
 - lib/rails_ai_context/output_guard.rb
 - lib/rails_ai_context/path_resolver.rb
 - lib/rails_ai_context/polyfill/data.rb
+- lib/rails_ai_context/portable_path.rb
 - lib/rails_ai_context/presets.rb
 - lib/rails_ai_context/redaction.rb
 - lib/rails_ai_context/resources.rb