rails-ai-context 5.21.2 → 5.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 986161d7fdb3003eca77d6f88b2820b5b76a35d72b5282d8f910b0e316b29298
-  data.tar.gz: 2fc004a71ff022abd1c1d216466936b27249c5da6dede308dece659b3cc311a8
+  metadata.gz: 8afb263c0004a822a803eee097300e87dcb5a3a2de27d996a3cc5f11ea801051
+  data.tar.gz: 462a8ca8d7f4a66cd617af71322356908f513aa88ac7aec2046f32cf4279805f
 SHA512:
-  metadata.gz: 4c335f590a135a3d8591bd52daef9673a59b4b9af150aebbe80cf91a39905098c7e215f5e77dea0dd07abf1aa9d94c96ac3586a2d487f0955ab3eb6220f51bc5
-  data.tar.gz: 230525933f4ccd784307c70ec97785b3b7df2cafedcb4720b9d7ae5d6b95239693ecd9e11d0651215ce177a4cf8e1144ef85dee82a061f62b21f0252e1fe5523
+  metadata.gz: 2f48e61abb15f942c9a3b41eced790ce41618f091e337d84c1d598486e74e3a58e3331c9acf971ad2fea0d0a0bb8a909caef4c6b9fd3196fba51dbe318532e97
+  data.tar.gz: 07e4b2759758da12d51805c0861e8a101fcdefdff55cba0db7714c6464473e486842fbd93c55b6480c8ce7b87325138fa18eb0920c38e219f0df3556a1ec0b19

data/CHANGELOG.md

@@ -5,6 +5,38 @@ 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

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,7 @@ 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,29 +110,11 @@ module RailsAiContext
         return nil unless loc
 
         path, line = loc
-        "#{relativize_source(path)}:#{line}"
+        "#{PortablePath.relativize(path, root)}:#{line}"
       rescue => e
         $stderr.puts "[rails-ai-context] block_source_location failed: #{e.message}" if ENV["DEBUG"]
         nil
       end
-
-      # These sources are written into .ai-context.json, which the app commits.
-      # An absolute path is wrong on every other machine and carries the
-      # generating developer's home directory, so app paths go app-relative and
-      # gem paths keep the gem and version instead of the install prefix.
-      def relativize_source(path)
-        return path.sub("#{root}/", "") if path.start_with?(root)
-
-        gem_roots.each do |gem_root|
-          return path.delete_prefix(gem_root) if path.start_with?(gem_root)
-        end
-        path
-      end
-
-      def gem_roots
-        @gem_roots ||= (Gem.path + [ Gem.default_dir ]).compact.uniq
-          .map { |dir| File.join(dir, "gems") + File::SEPARATOR }
-      end
     end
   end
 end

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/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/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/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.2"
+  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.1",
+  "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.2
+  version: 5.21.3
 platform: ruby
 authors:
 - crisnahine
@@ -384,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