rails-ai-context 5.30.0 → 5.30.2

data/lib/rails_ai_context/introspector.rb

@@ -52,6 +52,7 @@ module RailsAiContext
       warnings = []
       config.introspectors.each do |name|
         data = context[name]
+        portable_errors!(data)
         if data.is_a?(Hash) && data[:error]
           warnings << { introspector: name.to_s, error: data[:error] }
         end
@@ -133,12 +134,11 @@ module RailsAiContext
       # nothing about the database, and answering for it would be the
       # fabrication this method exists to remove.
       return if schema[:adapter].nil?
-      return unless SchemaAdapter.placeholder?(schema[:adapter])
 
       # "unknown" is a placeholder too. Swapping one for another buys nothing
       # and would bury the parse mode that at least says how the schema was read.
       resolved = SchemaAdapter.label(context)
-      return if SchemaAdapter.placeholder?(resolved)
+      return if SchemaAdapter.placeholder?(resolved) || resolved == schema[:adapter]
 
       schema[:adapter_source] = schema[:adapter]
       schema[:adapter] = resolved
@@ -178,6 +178,17 @@ module RailsAiContext
       end
     end
 
+    # An exception message names files by absolute path, and the context is committed.
+    def portable_errors!(data)
+      case data
+      when Hash
+        data[:error] = PortablePath.relativize_text(data[:error], app.root) if data[:error].is_a?(String) && !data.frozen?
+        data.each_value { |value| portable_errors!(value) }
+      when Array
+        data.each { |value| portable_errors!(value) }
+      end
+    end
+
     def unavailable_reason
       Introspectors::StaticTier.unavailable_reason
     end

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/database_stats_introspector.rb

@@ -2,8 +2,8 @@
 
 module RailsAiContext
   module Introspectors
-    # Collects approximate row counts from PostgreSQL's pg_stat_user_tables.
-    # Only activates for PostgreSQL adapter; returns { skipped: true } otherwise.
+    # Approximate row counts per table on PostgreSQL, MySQL and SQLite; any
+    # other adapter returns { skipped: true }.
     class DatabaseStatsIntrospector < Base
       extend StaticTier
       static_tier :runtime_only
@@ -13,12 +13,15 @@ module RailsAiContext
       # stats collection for every Trilogy app.
       MYSQL_ADAPTER = /mysql|trilogy/i
 
+      # activerecord-postgis-adapter reports "PostGIS" for what is a PostgreSQL connection.
+      POSTGRES_ADAPTER = /postg/i
+
       def call
         return { skipped: true, reason: "ActiveRecord not available" } unless defined?(ActiveRecord::Base)
 
         adapter = ActiveRecord::Base.connection.adapter_name.downcase
         case adapter
-        when /postgresql/
+        when POSTGRES_ADAPTER
           collect_postgresql_stats
         when MYSQL_ADAPTER
           collect_mysql_stats
@@ -32,18 +35,10 @@ module RailsAiContext
       private
 
       def collect_postgresql_stats
-        rows = ActiveRecord::Base.connection.select_all(<<~SQL)
-          SELECT relname AS table_name,
-                 n_live_tup AS approximate_row_count,
-                 n_dead_tup AS dead_rows
-          FROM pg_stat_user_tables
-          ORDER BY n_live_tup DESC
-        SQL
-
-        tables = rows.map do |row|
-          entry = { table: row["table_name"], approximate_rows: row["approximate_row_count"].to_i }
-          dead = row["dead_rows"].to_i
-          entry[:dead_rows] = dead if dead > 0
+        stats = PgPartitions.table_rows(ActiveRecord::Base.connection).sort_by { |t| [ -t[:rows], t[:name] ] }
+        tables = stats.map do |t|
+          entry = { table: t[:name], approximate_rows: t[:rows] }
+          entry[:dead_rows] = t[:dead_rows] if t[:dead_rows] > 0
           entry
         end
 

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
@@ -72,8 +125,8 @@ module RailsAiContext
             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,
+            column:      SchemaConventions.primary_key_value(options[:column]),
+            primary_key: SchemaConventions.primary_key_value(options[:primary_key]),
             location:    node.location.start_line
           }.compact
         end
@@ -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)