rails-ai-context 5.32.0 → 5.32.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d122147d8197ddd301336fd6df71fc21941676c20276e5297ae14e893840e520
-  data.tar.gz: a7e7979c52db2efb3653d1ccc2d8ea0ac491f3a009fc4d14001a8c22d28c1d54
+  metadata.gz: da0f12372e58a903300979aa8be03f53f53e9d5de073709e549a47b46cb8a5eb
+  data.tar.gz: cc0b3c5e77840cef702e9e163bd3e2d73f24a56ec324fbdfe3ec5b8c6e58eaf7
 SHA512:
-  metadata.gz: 994ce3426dfa3abf64ba88c4807fd3fd0206048a710037acfcd286ccc04b2a7286fcd69104eaeb09e449416a4fbc8a90a64dae7a14b4f170ec7de5defef6a38f
-  data.tar.gz: 21acba142c645343286465f2b4d615627d6d22983c91d803b8a241f17a0e21cf5d3bf634532fb415c55a883d253f88fd8b253f0da3c36bbe7cbf6bfe63ef48a8
+  metadata.gz: 5cc39f9e5208f88eea4ac18c3dac8a9abbe5da282c8a9b8f62594e5f9069483db9ced2f537768a97b864d17921b622ce7c640590e47546292fe3dafb5c7cd65e
+  data.tar.gz: 56d23208cbd739927ac9d85af26a39bfab5da0cebd75731791717bd67b83752bc28a096d1307e956ee9de593287b17efc70d91b81fa47c6deec2678beb064fd4

data/CHANGELOG.md

@@ -5,6 +5,70 @@ 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.32.1] - 2026-10-06
+
+### Fixed
+
+- **A structure.sql app names its PostgreSQL extensions the way the booted app
+  does.** The static tier named an extension bare only when it lived in
+  `public`. Rails names it bare when it lives in the connection's current
+  schema, the first entry of `schema_search_path`, so an app with
+  `schema_search_path: "app,public"` saw `app.pg_trgm` without a boot and
+  `pg_trgm` with one. The static tier now reads the search path from
+  config/database.yml, and on Rails before 8.0 names every extension bare, as
+  that connection does.
+- **Tables in every schema on the search path show without a boot.** The
+  static tier listed only the tables in `public`, while the booted app lists
+  every table in a schema on `schema_search_path` by its bare name. Both dump
+  formats now read the search path from config/database.yml, or its older
+  name `schema_order`, take `"$user"` as the configured username when the dump
+  creates that schema, and when two schemas hold the same table name, show the
+  one in the earlier schema, as PostgreSQL resolves it. When the search path
+  holds more than `public`, the schema answer names it on a `**Search path:**`
+  line, and the JSON answer under `search_path`.
+- **A table Rails 8.0 dumps twice lists its columns, foreign keys and check
+  constraints once.** Before Rails 8.1, schema.rb writes a table and its
+  foreign keys once per search path schema holding its name, and the static
+  tier listed each of them twice.
+- **A structure.sql app lists plpgsql, as the booted app does.** Every
+  PostgreSQL database starts with plpgsql, so the booted app lists it, but
+  pg_dump leaves it out of the dump. The static tier now adds it, named
+  `pg_catalog.plpgsql` on Rails 8 and `plpgsql` before, unless the dump drops it.
+- **Extensions are listed in name order, with or without a boot.** The booted
+  app listed them in the order the database created them and the static tier
+  in the order the dump wrote them, so the same app gave two orders.
+- **Enum types are named the way the booted app names them.** The enum list
+  holds the types in a schema on the search path, bare in the current schema and
+  schema-qualified otherwise, or every type by its bare name before Rails 7.1. A
+  column's enum type is bare when the search path finds that type first, and
+  qualified otherwise. A schema.rb from before Rails 8.1 already holds these
+  names and is read as written; a Rails 8.1 schema.rb qualifies every name, and
+  the static tier renames them. How the dump names things follows its
+  `ActiveRecord::Schema[8.1]` stamp, the Rails that wrote it, or none for one
+  Rails 6.1 or earlier wrote, so a schema.rb not dumped again since a Rails
+  upgrade still reads right; how the connection names them follows Gemfile.lock,
+  or the stamp when the lock names none. Both tiers list enum types in name
+  order, and a table's Enum types section pairs each column with the type the
+  search path finds for it, so a column `mood` whose type is `public.mood` shows
+  that entry. The booted app reads its search path with SQL on every Rails
+  version.
+- **A table outside the search path stays out of the table list but can still
+  be looked up.** Without a boot, a schema.rb table in another schema was
+  listed and counted, while the booted app leaves it out. Both tiers now leave
+  it out of the list in both dump formats, and both find it by its
+  schema-qualified name: `schema --table audit.events`, and the columns of a
+  model whose `table_name` is `audit.events`. A listed table is found by its
+  qualified name too, so `app.users` answers as `users` does. The booted app
+  reads such a table only when asked for it, so an app with a schema per
+  tenant pays nothing for it at boot. On Rails 8.1, whose schema.rb holds only
+  the search path schemas by default, the not-found answer for another
+  schema's table adds that `config.active_record.dump_schemas = :all`
+  includes it.
+- **`"$user"` on the search path reads the user from a database URL too.** A
+  `DATABASE_URL`, `<NAME>_DATABASE_URL` or the entry's `url:` now supplies the
+  username, and a `schema_search_path` in its query, over the entry's own
+  keys, as Rails merges a URL over the rest of the entry.
+
 ## [5.32.0] - 2026-10-06
 
 ### Added

data/docs/COMPATIBILITY.md

@@ -234,6 +234,11 @@ Proof sources:
    Sinatra and a plain gem); the lab regressions on SQLite in all three tiers,
    PostgreSQL and MySQL; and the unit suite on Ruby 3.1 with Rails 7.0 through
    Ruby 4.0 with Rails 8.1.
+   In the v5.32.1 release QA: a PostgreSQL 17 lab on Rails 8.1 and 8.0 with a
+   two-schema search path, answered booted and static from schema.rb and
+   structure.sql side by side; the small apps and the same private app
+   answering as v5.32.0 did; and the unit suite on Ruby 3.1 with Rails 7.0
+   through Ruby 4.0 with Rails 8.1.
 2. Non-crash coverage for every built-in tool including `get_view` in
    `spec/e2e/in_gemfile_install_spec.rb`'s full-tool sweep; output correctness
    (ivar cross-check, render-form detection, partial interfaces) verified
@@ -324,6 +329,22 @@ Postgres instance in `spec/e2e/postgres_install_spec.rb`, opt-in via
   in the static tier, so databases, replicas, sharding and `connects_to`
   declarations come from the files rather than from the live connection
   handlers. A database only a runtime `connects_to` names is missed.
+- **Rails 7.0 merges same-name enum types.** On Rails 7.0, two PostgreSQL enum
+  types with one name in different schemas come back from the connection as
+  one type holding both label lists; the static tier keeps the first type's
+  labels.
+- **A schema.rb from before Rails 8.1 does not say which schema holds a
+  table.** It names each table bare, whichever search path schema holds it,
+  so without a boot a schema-qualified name such as `app.users` finds a listed
+  table only when the search path has one schema. A Rails 7.0 schema.rb names
+  no schema at all, so the static tier takes every schema the search path
+  names as existing, except the one `"$user"` stands for.
+- **A dump made with a `schema_search_path` holds only those schemas.** By
+  default Rails passes each search path schema to pg_dump, so structure.sql
+  holds no other schema's tables and no extension, and a Rails 8.1 schema.rb
+  holds no other schema's tables. Without a boot those tables are not found and
+  the extension list is plpgsql alone. `config.active_record.dump_schemas =
+  :all` dumps everything.
 - **Inherited controller actions and filters are resolved by parent name, so
   some walks end early.** A controller that defines no action of its own takes
   the actions of the nearest app ancestor the listing holds, walked through the

data/docs/INTROSPECTORS.md

@@ -214,7 +214,7 @@ Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file
 | DefinitionFilePathsListener | Where a test helper points factory_bot: `FactoryBot.definition_file_paths =` (replaces the defaults) and `<<`/`+=`/`push`/`concat` (adds), each write as `{ replace:, paths: }` in the same forms as FixturePathsListener (`unread: true` and no paths when it cannot read them), and each `FactoryBot.find_definitions`/`FactoryBot.reload` as `{ load: }`, in source order; `::FactoryBot` counts |
 | ViewPathsListener | View roots `config/application.rb` adds to `config.paths["app/views"]`: `unshift` puts one before app/views, `<<`/`push`/`concat` after it, in the same literal forms as AutoloadPathsListener; a write whose path it cannot read is left out |
 | NamespacedRootsListener | Roots `config/application.rb` or an initializer hands Zeitwerk under a namespace: `push_dir(path, namespace: Const)`, as phlex:install writes, in the same literal forms as AutoloadPathsListener; a write whose path it cannot read is left out |
-| SchemaDslListener | `schema.rb`: `create_table`, `t.string`, `t.column`, `t.index`, `add_foreign_key`, `create_enum`, `create_view`, `create_virtual_table`, and the comment the dumper writes for a table it could not describe |
+| SchemaDslListener | `schema.rb`: `create_table`, `t.string`, `t.column`, `t.index`, `add_foreign_key`, `create_enum`, `create_schema`, `create_view`, `create_virtual_table`, the `ActiveRecord::Schema[x.y]` version stamp (a nil one for the unstamped `Schema.define` of Rails before 7.0), and the comment the dumper writes for a table it could not describe. Names drop `public.` unless `raw_names:` is set, which SchemaReader uses to name them against the search path |
 | MigrationDslListener | Migration DSL: `create_table`, `add_column`, `add_index`, `add_reference`, and friends |
 | MigrationReplayListener | What a replay needs beside the DSL: `def down`, `down`/`revert` blocks, and `t.timestamps` |
 | RoutesDslListener | `config/routes.rb`, resolving namespace/scope/resources nesting into flat routes (a `controller:` with a leading slash is absolute, as in Rails); routing concerns (`concern` definitions replayed at each `concerns:` site), `with_options` defaults merged under each inner call, `match ... via:` (or the `via:` of an enclosing `scope`) as one route answering each verb it names (`GET|POST`, and `ANY` for `via: :all`, as the booted table has it), the controller a `scope(controller:)` or a route's own `controller:` names (with Rails' `a/b` shorthand when no action is given), and the `as:`, `param:`, `module:`, `path:` and `only:`/`except:` options. A block drawn through an app class (`ApiRouteSet::V1.draw(self) do`) takes the path and `as:` prefixes that class's `self.prefix` and `mapper_prefix` return as literals, or a literal prefix argument; a class whose prefix is not a literal, and that class's own `resources`, are counted as unexpanded. Routes drawn into an engine's table (`Spree::Core::Engine.routes.draw`) sit under the engine's namespace and carry `engine:`, which the route introspector files under that engine's mount, apart from the app's count. A file pulled in by `draw` is walked inside the scope its `draw` sits in, once per scope that draws it, so `draw :api` under `namespace :api` and `scope module: :v1` routes to `api/v1/...` at `/api/...` |

data/lib/rails_ai_context/database_yml.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "uri"
 require "yaml"
 
 module RailsAiContext
@@ -69,6 +70,41 @@ module RailsAiContext
       databases(root)[primary_name(root)]
     end
 
+    # A database's schema_search_path as PostgreSQL reads it: an unquoted name folds to
+    # lowercase and "$user" is the configured username. Unset, PostgreSQL's "$user", public.
+    # namespace.c recomputeNamespacePath keeps a repeated schema's first place only.
+    def schema_search_path(root, name = "primary")
+      search_path_entries(root, name).map(&:first).uniq
+    end
+
+    # The schema only the search path's "$user" names, or nil: one the path also names outright is configured.
+    def user_schema(root, name = "primary")
+      entries = search_path_entries(root, name)
+      user = entries.find(&:last)&.first
+      user unless entries.any? { |schema, from_user| !from_user && schema == user }
+    end
+
+    # [schema, from_user] per search path entry.
+    def search_path_entries(root, name)
+      settings = entry(root, name)
+      settings = {} unless settings.is_a?(Hash)
+      known = adapter(name, settings).first
+      return [ [ "public", false ] ] if known && !known.start_with?("postg")
+
+      settings = settings.merge(url_settings(name, settings["url"]))
+      # postgresql_adapter.rb:984 (8.1), :865 (7.0): schema_order is the older name.
+      text = (settings["schema_search_path"] || settings["schema_order"]).to_s
+      text = '"$user", public' if text.strip.empty?
+      user = settings["username"].to_s
+      text.split(",").filter_map do |part|
+        part = part.strip
+        next if part.empty? || computed?(part)
+        next ([ user, true ] unless user.empty? || computed?(user)) if part.delete('"') == "$user"
+
+        [ part.start_with?('"') ? part.delete('"') : part.downcase, false ]
+      end
+    end
+
     # The named database's settings in the running environment, or nil.
     def entry(root, name)
       entry_in(databases(root), name)
@@ -99,13 +135,27 @@ module RailsAiContext
     # Rails' DatabaseConfigurations: an entry's own url wins over its keys, and an entry
     # without one takes <NAME>_DATABASE_URL, or DATABASE_URL for the primary.
     def url_adapter(name, own_url)
-      url = own_url.nil? ? ENV["#{name.upcase}_DATABASE_URL"] || (ENV["DATABASE_URL"] if name == "primary") : own_url.to_s
-      return nil if url.to_s.empty? || computed?(url)
+      url = url_for(name, own_url) or return nil
 
       scheme = url[/\A([a-z][a-z0-9+.-]*):/i, 1]&.tr("-", "_")
       scheme && URL_SCHEME_ADAPTERS.fetch(scheme, scheme)
     end
 
+    def url_for(name, own_url)
+      url = own_url.nil? ? ENV["#{name.upcase}_DATABASE_URL"] || (ENV["DATABASE_URL"] if name == "primary") : own_url.to_s
+      url unless url.to_s.empty? || computed?(url)
+    end
+
+    # The username and schema_search_path a database URL carries, which Rails merges over the entry's keys.
+    def url_settings(name, own_url)
+      uri = URI.parse(url_for(name, own_url).to_s)
+      found = uri.query ? URI.decode_www_form(uri.query).to_h.slice("schema_search_path") : {}
+      found["username"] = URI.decode_www_form_component(uri.user) if uri.user
+      found
+    rescue URI::Error, ArgumentError
+      {}
+    end
+
     # [adapter, from_default]: the URL's scheme wins, then the entry's adapter. An ERB-computed
     # value is unknown unless it is one tag carrying its own literal default.
     def adapter(name, entry)

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

@@ -52,12 +52,18 @@ module RailsAiContext
         # The dumper writes a comment, not a create_table, for a table it could not describe.
         NOT_DUMPED = /\A#\s*Could not dump table "([^"]+)" because of following (\S+)/
 
+        # raw_names: each name as the dump writes it, for a reader that names them after the walk.
+        def initialize(raw_names: false)
+          super()
+          @raw_names = raw_names
+        end
+
         def on_program_node_enter(_node)
           comments = Array(@comments)
           comments.each_with_index do |comment, i|
             match = NOT_DUMPED.match(comment.location.slice) or next
             message = comments[i + 1]&.location&.slice.to_s[/\A#\s+(\S.*)/, 1]
-            @results << { type: :not_dumped, table: SchemaConventions.local_name(match[1]),
+            @results << { type: :not_dumped, table: local_name(match[1]),
                           reason: [ match[2], message ].compact.join(": "), location: comment.location.start_line }
           end
         end
@@ -66,6 +72,13 @@ module RailsAiContext
           note_block(node)
           if node.receiver.nil?
             extract_top_level_call(node)
+          elsif node.name == :[] && node.receiver.is_a?(Prism::ConstantPathNode) && node.receiver.slice == "ActiveRecord::Schema"
+            # ActiveRecord::Schema[8.1].define: the Rails version that wrote the dump.
+            stamp = node.arguments&.arguments&.first
+            @results << { type: :stamp, version: stamp.slice, location: node.location.start_line } if stamp.is_a?(Prism::FloatNode)
+          elsif node.name == :define && node.receiver.is_a?(Prism::ConstantPathNode) && node.receiver.slice == "ActiveRecord::Schema"
+            # Rails before 7.0 writes no stamp.
+            @results << { type: :stamp, version: nil, location: node.location.start_line }
           elsif column_call?(node)
             extract_column(node)
           elsif index_call?(node)
@@ -87,6 +100,11 @@ module RailsAiContext
 
         private
 
+        # Without a search path to read, public's are the bare names.
+        def local_name(name)
+          @raw_names ? name : name.delete_prefix("public.")
+        end
+
         def read_elsewhere?(name)
           OTHER_TABLE_METHODS.include?(name) || MigrationReplayListener::TABLE_OPS.key?(name)
         end
@@ -104,6 +122,9 @@ module RailsAiContext
             extract_foreign_key(node)
           when :create_enum
             extract_enum(node)
+          when :create_schema
+            name = literal_string(node.arguments&.arguments&.first)
+            @results << { type: :create_schema, name: name, location: node.location.start_line } if name
           when :add_index
             extract_top_level_add_index(node)
           when :add_check_constraint
@@ -123,7 +144,7 @@ module RailsAiContext
           name = literal_string(node.arguments&.arguments&.first) or return
           options = extract_keyword_nodes(node)
           @results << {
-            type: :view, name: SchemaConventions.local_name(name), materialized: options[:materialized].is_a?(Prism::TrueNode),
+            type: :view, name: local_name(name), materialized: options[:materialized].is_a?(Prism::TrueNode),
             sql: literal_string(options[:sql_definition])&.strip, location: node.location.start_line
           }.compact
         end
@@ -143,7 +164,7 @@ module RailsAiContext
 
           @results << {
             type:     :create_table,
-            table:    SchemaConventions.local_name(table_arg.unescaped),
+            table:    local_name(table_arg.unescaped),
             # id: false / id: :uuid / primary_key: ... decide whether the
             # implicit primary-key column exists and what to call it.
             options:  extract_keyword_options(node),
@@ -161,8 +182,8 @@ module RailsAiContext
 
           @results << {
             type:        :foreign_key,
-            from:        SchemaConventions.local_name(from_arg.unescaped),
-            to:          SchemaConventions.local_name(to_arg.unescaped),
+            from:        local_name(from_arg.unescaped),
+            to:          local_name(to_arg.unescaped),
             # Absent means the Rails convention holds; naming it here would
             # make a declared column indistinguishable from a guessed one.
             column:      SchemaConventions.primary_key_value(options[:column]),
@@ -191,7 +212,7 @@ module RailsAiContext
 
           @results << {
             type:     :enum,
-            name:     SchemaConventions.local_name(name_arg.unescaped),
+            name:     local_name(name_arg.unescaped),
             values:   values,
             location: node.location.start_line
           }
@@ -207,7 +228,7 @@ module RailsAiContext
 
           @results << {
             type:     :add_index,
-            table:    SchemaConventions.local_name(table_arg.unescaped),
+            table:    local_name(table_arg.unescaped),
             columns:  columns,
             options:  options,
             location: node.location.start_line
@@ -222,7 +243,7 @@ module RailsAiContext
 
           @results << {
             type:       :add_check_constraint,
-            table:      SchemaConventions.local_name(table_arg.unescaped),
+            table:      local_name(table_arg.unescaped),
             expression: expr_arg.unescaped,
             name:       literal_string(extract_keyword_nodes(node)[:name]),
             location:   node.location.start_line
@@ -288,7 +309,7 @@ module RailsAiContext
 
           options = braced.map { |hash| hash_node_to_hash(hash) }.reduce(extract_keyword_options(node), :merge)
           virtual = node.name == :virtual
-          options[:enum_type] = SchemaConventions.local_name(options[:enum_type]) if options[:enum_type].is_a?(String)
+          options[:enum_type] = local_name(options[:enum_type]) if options[:enum_type].is_a?(String)
           # A generated column takes its own type from type: (each adapter's virtual, 7.0 to 8.1).
           column_type = options[:type].to_s if virtual && (options[:type].is_a?(Symbol) || options[:type].is_a?(String))
           names.each do |col_name|

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -172,7 +172,7 @@ module RailsAiContext
       # Rails runs no STI on a table without the type column; a table the dump does not hold is not known to lack it.
       def lacks_column?(table, column)
         reader = SchemaReader.for(app.root)
-        reader.tables.key?(table) && column != RailsAiContext::Confidence::INFERRED && !reader.column?(table, column)
+        reader.table?(table) && column != RailsAiContext::Confidence::INFERRED && !reader.column?(table, column)
       end
 
       # Rails' default column, the literal a class sets, or nil where `inheritance_column = nil` turns STI off.

data/lib/rails_ai_context/introspectors/pg_naming.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # How Rails' PostgreSQL connection and schema.rb dumper name extensions, enum types and
+    # relations, by Rails version, so the static tier names them as the booted app does.
+    # Each rule cites the activerecord source it mirrors.
+    module PgNaming
+      DEFAULT_SEARCH_PATH = %w[public].freeze
+      # 6.1 schema_dumper.rb:89 writes Schema.define, 7.0 :90 Schema[x.y]; every rule here starts at 7.0 or later.
+      UNSTAMPED_DUMP = "6.1"
+
+      module_function
+
+      # The running Rails when booted, else the lockfile's; nil when neither says.
+      def rails_version(root)
+        return Rails.version if defined?(Rails) && Rails.respond_to?(:version) && !RailsAiContext.static_tier?
+
+        lock = GemLock.for(root)
+        lock.version("rails") || lock.version("railties")
+      end
+
+      # An unknown version takes the newest rules.
+      def at_least?(version, release)
+        version.nil? || Gem::Version.new(version) >= Gem::Version.new(release)
+      end
+
+      # 8.0 postgresql_adapter.rb:506-520 drops the schema only when it is current_schema;
+      # 7.0 :453, 7.1 :497 and 7.2 :496 select extname alone.
+      def extension_name(name, schema, path, version)
+        return name if schema.nil? || !at_least?(version, "8.0") || schema == path.first
+
+        "#{schema}.#{name}"
+      end
+
+      # 7.1 postgresql_adapter.rb:502-522 (to 8.1 :533-553): the types in current_schemas(false),
+      # bare in current_schema. 7.0 :458-469 merges same-name types' labels; the static tier keeps the first set.
+      def enum_list(enums, path, version)
+        legacy = !at_least?(version, "7.1")
+        listed = enums.filter_map do |name, values|
+          schema, dot, bare = name.rpartition(".")
+          shown = if dot.empty? || legacy then bare
+          elsif path.include?(schema) then schema == path.first ? bare : name
+          end
+          { name: shown, values: values } if shown
+        end
+        listed.uniq { |enum| enum[:name] }.sort_by { |enum| enum[:name] }
+      end
+
+      # 8.1 schema_dumper.rb:154-162 (relation_name) qualifies every name in a dump of more than one
+      # schema. Before, the dumper writes connection.tables, enum_types and column.sql_type
+      # (7.2 postgresql/schema_dumper.rb:19-29, :94), the names the booted app reads.
+      def dump_qualifies_names?(version)
+        at_least?(version, "8.1")
+      end
+
+      # Whether a bare name in the dump says its schema. Before 8.1 the dumper names each of
+      # connection.tables bare, whichever search path schema holds it, so only a one-schema path places it.
+      def dump_places_names?(version, path)
+        dump_qualifies_names?(version) || path.size < 2
+      end
+
+      # 7.1 postgresql/schema_dumper.rb:31-40 writes create_schema for every schema; 7.0 has no schemas().
+      def dump_lists_schemas?(version)
+        at_least?(version, "7.1")
+      end
+
+      # current_schemas(false) skips a schema that does not exist; pg_dump never creates public.
+      def existing_path(path, created)
+        path.select { |schema| schema == "public" || created.include?(schema) }
+      end
+
+      # The names a dump's relations and enum types go by, given its qualified names.
+      def names(path, relations: [], types: [])
+        Names.new(path, shadowed(relations, path), shadowed(types, path))
+      end
+
+      # The qualified names an earlier search path schema hides by holding the same bare name.
+      def shadowed(names, path)
+        return Set.new if path.size < 2
+
+        ranked = names.uniq.filter_map do |name|
+          schema, dot, bare = name.rpartition(".")
+          rank = path.index(schema) unless dot.empty?
+          [ rank, bare, name ] if rank
+        end
+        first = ranked.sort_by(&:first).reverse.to_h { |_, bare, name| [ bare, name ] }
+        ranked.filter_map { |_, bare, name| name unless first[bare] == name }.to_set
+      end
+
+      # PostgreSQL resolves a bare name through the search path (data_sources and format_type alike).
+      Names = Struct.new(:path, :shadowed_relations, :shadowed_types) do
+        def relation(name)
+          visible(name, shadowed_relations)
+        end
+
+        def type(name)
+          visible(name, shadowed_types)
+        end
+
+        private
+
+        def visible(name, shadowed)
+          schema, dot, bare = name.rpartition(".")
+          dot.empty? || !path.include?(schema) || shadowed.include?(name) ? name : bare
+        end
+      end
+
+      # The enum types a table's columns use: a bare column type is the first search path schema's
+      # holding it, and a bare list name is the current schema's.
+      def enums_used(enum_types, column_types, path)
+        path = Array(path).presence || DEFAULT_SEARCH_PATH
+        listed = Array(enum_types).to_h { |enum| [ enum[:name].to_s.include?(".") ? enum[:name].to_s : "#{path.first}.#{enum[:name]}", enum ] }
+        used = column_types.map do |type|
+          type.include?(".") ? type : path.map { |schema| "#{schema}.#{type}" }.find { |key| listed.key?(key) }
+        end
+        listed.select { |key, _| used.include?(key) }.values
+      end
+
+      # 8.1 postgresql/schema_dumper.rb:13-23, :50-68 dumps only ActiveRecord.dump_schemas, the search
+      # path by default (active_record.rb:436); 7.1 to 8.0 dump every schema's create_schema and ignore it.
+      # A dump naming no schema off the path is the default; one that does has dump_schemas set.
+      def missing_from_schema_rb(name, path, created, version, dump)
+        schema, dot, = name.to_s.rpartition(".")
+        return if dot.empty? || !at_least?(version, "8.1") || path.include?(schema) || created.include?(schema)
+        return unless (created - path).empty?
+
+        "If schema '#{schema}' exists, #{dump} leaves it out: Rails 8.1 dumps only the search path schemas there by default. " \
+          "`config.active_record.dump_schemas = :all` includes it."
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/schema_conventions.rb

@@ -189,12 +189,6 @@ module RailsAiContext
         yml.adapter(db_name, entry).first || (yml.adapter("primary", yml.primary(root)).first unless entry)
       end
 
-      # A dump of more than one schema qualifies every name (relation_name, 8.1);
-      # the app sees a public table by its bare name under the default search_path.
-      def local_name(name)
-        name.delete_prefix("public.")
-      end
-
       # A primary key as connection.primary_key gives it: the column's name, or
       # the names in order for a composite key; nil for none.
       def primary_key_value(key)