rails-ai-context 5.30.0 → 5.30.2

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

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

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

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

data/lib/rails_ai_context/introspectors/migration_replay.rb

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

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -844,7 +844,8 @@ module RailsAiContext
           type: assoc.macro.to_s,
           # A leading `::` stays: it means top level to the class resolver.
           class_name: assoc.class_name.to_s,
-          foreign_key: assoc.foreign_key.to_s
+          # Rails 7.1+ answers an Array for a composite key.
+          foreign_key: assoc.foreign_key.is_a?(Array) ? assoc.foreign_key.map(&:to_s) : assoc.foreign_key.to_s
         }
         detail[:through]    = assoc.options[:through].to_s if assoc.options[:through]
         detail[:source_type] = assoc.options[:source_type].to_s if assoc.options[:source_type]
@@ -1292,9 +1293,9 @@ module RailsAiContext
 
         shaped = assoc.merge(assoc[:name] ? { name: assoc[:name].to_s } : {})
         options = assoc[:options]
-        return shaped unless options.is_a?(Hash)
+        return with_default_foreign_key(shaped) unless options.is_a?(Hash)
 
-        LIFTED_ASSOCIATION_OPTIONS.each_with_object(shaped) do |key, acc|
+        lifted = LIFTED_ASSOCIATION_OPTIONS.each_with_object(shaped) do |key, acc|
           next unless options.key?(key) && !acc.key?(key)
 
           value = options[key]
@@ -1303,9 +1304,19 @@ module RailsAiContext
           next if value.nil?
 
           acc[key] = if BOOLEAN_ASSOCIATION_OPTIONS.include?(key) then value
+          elsif value.is_a?(Array) then value.map(&:to_s)
           else value.to_s
           end
         end
+        with_default_foreign_key(lifted)
+      end
+
+      # Reflection answers a belongs_to's key when none is declared: the name plus _id.
+      def with_default_foreign_key(assoc)
+        return assoc unless assoc[:type] == "belongs_to" && !assoc.key?(:foreign_key)
+        return assoc if assoc[:computed_name] || assoc[:name].to_s.empty?
+
+        assoc.merge(foreign_key: SchemaConventions.reference_column_name(assoc[:name]))
       end
 
       # A value that survives as itself: `in: %w[draft sent]` reached

data/lib/rails_ai_context/introspectors/pg_partitions.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # A partition repeats its parent's columns, indexes and keys, so it is listed
+    # as its partitioned parent, and its rows, bytes and index scans count there.
+    module PgPartitions
+      module_function
+
+      # activerecord-postgis-adapter reports "PostGIS" for what is a PostgreSQL connection.
+      POSTGRES_ADAPTER = /postg/i
+
+      # Scoped the way connection.tables is.
+      NAMES_SQL = <<~SQL.squish.freeze
+        SELECT c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relispartition AND c.relkind IN ('r', 'p') AND n.nspname = ANY (current_schemas(false))
+      SQL
+
+      def names(conn)
+        # relispartition arrived with partitions in 10; querying it before then
+        # fails, and a failed query aborts any open transaction.
+        return [] unless conn.adapter_name.match?(POSTGRES_ADAPTER) && conn.database_version >= 10_00_00
+
+        conn.select_values(NAMES_SQL)
+      rescue => e
+        RailsAiContext.debug_fail(e, [], label: "PgPartitions.names")
+      end
+
+      # @return [Array<Hash>] { name:, rows:, dead_rows: } per table, from the statistics alone
+      def table_rows(conn)
+        per_table(conn, "SUM(s.n_live_tup) AS live_rows, SUM(s.n_dead_tup) AS dead_rows").map do |r|
+          { name: r["name"], rows: r["live_rows"].to_i, dead_rows: r["dead_rows"].to_i }
+        end
+      end
+
+      # @return [Array<Hash>] { name:, bytes: } per table. Sizing a relation waits on its lock.
+      def table_bytes(conn)
+        per_table(conn, "SUM(pg_total_relation_size(s.relid)) AS bytes").map do |r|
+          { name: r["name"], bytes: r["bytes"].to_i }
+        end
+      end
+
+      # @return [Array<Hash>] { table:, index:, scans: } per index, from pg_stat_user_indexes
+      def index_stats(conn)
+        conn.select_all(<<~SQL).map do |r|
+          SELECT t.relname AS table_name, i.relname AS index_name, SUM(s.idx_scan) AS scans
+          FROM pg_stat_user_indexes s
+          JOIN pg_class t ON t.oid = #{root_of(conn, "s.relid")}
+          JOIN pg_class i ON i.oid = #{root_of(conn, "s.indexrelid")}
+          GROUP BY t.oid, t.relname, i.oid, i.relname
+        SQL
+          { table: r["table_name"], index: r["index_name"], scans: r["scans"].to_i }
+        end
+      end
+
+      def per_table(conn, sums)
+        conn.select_all(<<~SQL)
+          SELECT c.relname AS name, #{sums}
+          FROM pg_stat_user_tables s
+          JOIN pg_class c ON c.oid = #{root_of(conn, "s.relid")}
+          GROUP BY c.oid, c.relname
+        SQL
+      end
+      private_class_method :per_table
+
+      def root_of(conn, relid)
+        # ponytail: pg_partition_root needs PostgreSQL 12, so on 10 and 11 each partition stays its own row.
+        conn.database_version >= 12_00_00 ? "COALESCE(pg_partition_root(#{relid}), #{relid})" : relid
+      end
+      private_class_method :root_of
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/route_introspector.rb

@@ -53,6 +53,9 @@ module RailsAiContext
         return { error: "config/routes.rb not found in #{app.root}" } if top_files.empty?
 
         records, mounts, files = walk_route_files(top_files)
+        in_repo = in_repo_routes(mounts)
+        records += in_repo.values.flat_map(&:first)
+        mounts = (mounts + in_repo.values.flat_map(&:last)).uniq { |mount| [ mount[:engine], mount[:path] ] }
         # What an app draws into an engine's table is the engine's, which the
         # booted tier's Rails.application.routes holds only as the mount.
         app_records, engine_records = records.partition { |r| r[:engine].nil? }
@@ -79,21 +82,51 @@ module RailsAiContext
           confidence: Confidence::STATIC
         }
         result[:dynamic_routes] = dynamic if dynamic.positive?
-        engine_routes = engine_route_groups(engine_records, mounts)
+        engine_routes = engine_route_groups(engine_records, mounts) + unread_engine_tables(engine_records, mounts)
         result[:engine_routes] = engine_routes if engine_routes.any?
-        unread = in_repo_route_files.size
+        unread = (in_repo_route_files - in_repo.keys).size
         result[:in_repo_route_files] = unread if unread.positive?
         result
       end
 
-      # An in-repo engine's routes.rb draws into its own table, which only boot can place, so
-      # the count says those routes were skipped instead of reading as the whole total.
+      # Every routes.rb under an in-repo engine or plugin root. One the app does not mount has
+      # no place in the static table, so the count says it was skipped.
       def in_repo_route_files
         PathResolver.code_roots(app.root.to_s)
           .map { |dir| File.join(dir, "config", "routes.rb") }
           .select { |path| File.exist?(path) }
       end
 
+      # Rails loads every engine's routes.rb. One that appends to the app's own
+      # table adds app routes; one that draws into an engine the app mounts is
+      # placed under the mount.
+      # @return [Hash] path => [records, mounts], for files read into the app's table
+      def in_repo_routes(mounts)
+        walked = in_repo_route_files.to_h { |path| [ path, walk_routes_file(path) ] }
+        app_files = walked.keys.select { |path| app_route_file?(path) }.to_set
+        mounted = (mounts + app_files.flat_map { |path| walked[path][1] }).map { |m| m[:engine] }.to_set
+        walked.each_with_object({}) do |(path, (records, file_mounts, _files)), found|
+          app = app_files.include?(path)
+          kept = records.select { |r| r[:engine] ? mounted.include?(r[:engine]) : app }
+          file_mounts = app ? file_mounts : []
+          # A file that draws nothing (all commented out) has nothing left unread.
+          found[path] = [ kept, file_mounts ] if kept.any? || file_mounts.any? || records.empty?
+        end
+      end
+
+      # `Rails.application.routes` or `X::Application.routes`, drawn, appended or prepended.
+      def app_route_file?(path)
+        AstWalk.each(AstCache.parse_string(SafeFile.read(path).to_s).value).any? do |node|
+          next false unless node.is_a?(Prism::CallNode) && %i[draw append prepend].include?(node.name) && node.block
+
+          routes = node.receiver
+          routes.is_a?(Prism::CallNode) && routes.name == :routes &&
+            routes.receiver&.slice.to_s.delete_prefix("::").match?(/\A(Rails\.application|(\w+::)*Application)\z/)
+        end
+      rescue StandardError, ScriptError => e
+        RailsAiContext.debug_fail(e, false, label: "app_route_file? #{path}")
+      end
+
       # What config/routes.rb and every file it draws mount, from source. The
       # engines section reads this rather than walking config/routes.rb on its
       # own, so the two sections name one set of mounted apps.
@@ -126,11 +159,36 @@ module RailsAiContext
               ).compact
             end),
             dynamic_routes: dynamic.positive? ? dynamic : nil,
+            mount_computed: (true if mount_record && mount.nil?),
             also_mounted_at: mount_records.drop(1).map { |m| m[:path] }.presence
           }.compact
         end
       end
 
+      # An engine the app draws nothing into still has its own table, drawn in
+      # its own code, which only boot reads. A mounted Rack app has no table at all.
+      def unread_engine_tables(engine_records, mounts)
+        drawn = engine_records.map { |r| r[:engine] }.to_set
+        roots = PathResolver.autoload_roots(app.root.to_s) + PathResolver.path_gem_libs(app.root.to_s)
+        mounts.reject { |m| drawn.include?(m[:engine]) }
+          .group_by { |m| m[:engine] }
+          .select { |engine, _| engine_constant?(engine, roots) }
+          .map do |engine, same|
+            { engine: engine, mount: same.first[:path], mount_computed: (true unless same.first[:path]), routes: [],
+              also_mounted_at: same.drop(1).map { |m| m[:path] }.presence,
+              unavailable: "the engine's own routes are read only with the app booted" }.compact
+          end
+      end
+
+      # The app's own definition says whether it subclasses Rails::Engine; a
+      # gem's constant is read nowhere here, so its name is all there is.
+      def engine_constant?(name, roots)
+        path = PathResolver.file_for_constant(app.root.to_s, name, roots: roots)
+        return name.to_s.match?(/(?:\A|::)Engine\z/) unless path
+
+        SafeFile.read(path).to_s.match?(/<\s*(?:::)?Rails::Engine\b/)
+      end
+
       # Rails names the proxy after the mount: its `as:`, else the engine's
       # engine_name, under the names of the scopes around it.
       def route_proxy(engine, mount)

data/lib/rails_ai_context/introspectors/schema_conventions.rb

@@ -32,8 +32,8 @@ module RailsAiContext
       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"
+          column: primary_key_value(column) || "#{to.to_s.singularize}_id",
+          primary_key: primary_key_value(primary_key) || "id"
         }
       end
 
@@ -63,6 +63,21 @@ module RailsAiContext
         (key ? leading << key.to_s : leading).to_set
       end
 
+      # A table whose block called what no reader interprets may have indexes
+      # the static schema lacks.
+      def note_unread_call(table, name)
+        return unless table
+
+        table[:unread_calls] = Array(table[:unread_calls]) | [ name.to_s ]
+      end
+
+      # A key as a reader writes it beside another key: `id`, or `(id, day)`, so
+      # the two sides of a foreign key stay apart.
+      def key_text(value)
+        columns = Array(value).map(&:to_s)
+        columns.size > 1 ? "(#{columns.join(", ")})" : columns.first.to_s
+      end
+
       # A partial index's condition as the dump wrote it, for the end of a line.
       def where_clause(where)
         where ? " where #{where}" : ""

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -12,6 +12,7 @@ module RailsAiContext
       def call
         return attach_secondary_databases(static_schema_parse) unless active_record_connected?
 
+        @partitions = PgPartitions.names(connection)
         if table_names.empty?
           # Connected but not migrated: the files answer, and the notes say so.
           @connection_state = "connected, no tables yet"
@@ -30,8 +31,10 @@ module RailsAiContext
           declared_tables: declared_table_names,
           check_constraints: check_constraints,
           enum_types: enum_types,
-          generated_columns: generated_columns(schema_reader)
-        })
+          generated_columns: generated_columns(schema_reader),
+          # What names the migration behind a declared table the connection lacks.
+          pending_migrations: RailsAiContext::PendingMigrations.live(RailsAiContext::PendingMigrations.migrate_dir_for(app.root))
+        }.compact)
       end
 
       # Static tier entry: skip the connection probe entirely and answer from
@@ -77,7 +80,8 @@ module RailsAiContext
       end
 
       def table_names
-        @table_names ||= connection.tables.reject { |t| t.start_with?("ar_internal_metadata", "schema_migrations") }
+        @table_names ||= (connection.tables - @partitions.to_a)
+          .reject { |t| t.start_with?("ar_internal_metadata", "schema_migrations") }
       end
 
       def extract_tables
@@ -135,7 +139,8 @@ module RailsAiContext
       end
 
       def extract_foreign_keys(table)
-        connection.foreign_keys(table).map do |fk|
+        # PostgreSQL clones a key that references a partitioned table once per partition.
+        connection.foreign_keys(table).reject { |fk| @partitions.to_a.include?(fk.to_table) }.map do |fk|
           {
             from_table: fk.from_table,
             to_table: fk.to_table,
@@ -158,7 +163,7 @@ module RailsAiContext
       end
 
       def schema_reader
-        @schema_reader ||= SchemaReader.new(schema_file_path)
+        @schema_reader ||= SchemaReader.new(schema_file_path, partitions: @partitions.to_a)
       end
 
       # Constraints and enum types are declared in the dump, not reported by
@@ -352,8 +357,9 @@ module RailsAiContext
           tables[table_name] = {
             columns: declared[:columns].map { |c| static_column(c) },
             indexes: declared[:indexes].filter_map { |i| static_index(i) },
-            foreign_keys: []
-          }
+            foreign_keys: [],
+            unread_calls: declared[:unread_calls]
+          }.compact
           key = declared.dig(:options, :primary_key)
           tables[table_name][:primary_key] = SchemaConventions.primary_key_value(key) if key
         end

data/lib/rails_ai_context/introspectors/schema_reader.rb

@@ -59,9 +59,12 @@ module RailsAiContext
 
       attr_reader :source
 
-      def initialize(path, pk_type: nil)
+      # partitions: the tables the database says are partitions, which a
+      # schema.rb from before Rails 8 dumps as plain tables.
+      def initialize(path, pk_type: nil, partitions: [])
         @path = path
         @pk_type = pk_type
+        @partitions = partitions
         @source = File.exist?(path.to_s) ? :schema_rb : :none
       end
 
@@ -147,11 +150,32 @@ module RailsAiContext
           current = absorb(event, schema, current)
         end
 
-        schema
+        drop_partitions(schema)
       rescue => e
         RailsAiContext.debug_fail(e, empty_schema, label: "SchemaReader")
       end
 
+      # Rails dumps a partition as a table inheriting its parent, and PostgreSQL
+      # lets only a partition inherit a partitioned table.
+      def drop_partitions(schema)
+        table_options = schema[:tables].transform_values { |t| t.dig(:options, :options).to_s }
+        partitioned = table_options.select { |_, o| o.start_with?("PARTITION BY") }.keys
+        dumped_partitions = []
+        loop do
+          found = table_options.select { |_, o| partitioned.include?(o[/\AINHERITS \(([^,]+)\)\z/, 1]) }.keys - dumped_partitions
+          break if found.empty?
+
+          dumped_partitions.concat(found)
+          partitioned.concat(found)
+        end
+        partitions = dumped_partitions | @partitions
+
+        partitions.each { |name| schema[:tables].delete(name) }
+        schema[:foreign_keys].reject! { |fk| partitions.include?(fk[:from]) || partitions.include?(fk[:to]) }
+        schema[:check_constraints].reject! { |c| partitions.include?(c[:table]) }
+        schema
+      end
+
       # AstCache caps parses below the configured schema limit, so a dump
       # between the two has to be parsed directly. Everything under the cap
       # goes through the cache, which the other introspectors share.
@@ -186,6 +210,8 @@ module RailsAiContext
           schema[:tables][current]&.dig(:columns)&.push(column_entry(event)) if current
         when :index
           schema[:tables][current]&.dig(:indexes)&.push(index_entry(event)) if current
+        when :unread_call
+          SchemaConventions.note_unread_call(schema[:tables][current], event[:name]) if current
         when :add_index
           schema[:tables][event[:table]]&.dig(:indexes)&.push(index_entry(event))
         when :foreign_key

data/lib/rails_ai_context/introspectors/structure_sql_reader.rb

@@ -54,10 +54,13 @@ module RailsAiContext
         # [^;]*? keeps the match inside one statement: with .*? a pkey-only
         # ADD CONSTRAINT would swallow up to the FOREIGN KEY of a LATER
         # statement and attribute the FK to the wrong table.
-        content.scan(/ALTER TABLE\s+(?:ONLY\s+)?(?:public\.)?[`"]?(\w+)[`"]?\s+ADD CONSTRAINT[^;]*?FOREIGN KEY\s*\([`"]?(\w+)[`"]?\)\s*REFERENCES\s+(?:public\.)?[`"]?(\w+)[`"]?\s*\([`"]?(\w+)[`"]?\)/m) do |from, col, to, pk|
-          tables[from]&.dig(:foreign_keys)&.push({ from_table: from, to_table: to, column: col, primary_key: pk })
+        content.scan(/ALTER TABLE\s+(?:ONLY\s+)?(?:public\.)?[`"]?(\w+)[`"]?\s+ADD CONSTRAINT[^;]*?FOREIGN KEY\s*\(([^)]*)\)\s*REFERENCES\s+(?:public\.)?[`"]?(\w+)[`"]?\s*\(([^)]*)\)/m) do |from, cols, to, pks|
+          tables[from]&.dig(:foreign_keys)&.push(SchemaConventions.foreign_key_entry(from, to, cols.scan(/\w+/), pks.scan(/\w+/)))
         end
 
+        # pg_dump writes each partition as a table, then attaches it in exactly this form.
+        content.scan(/^ALTER TABLE ONLY .+? ATTACH PARTITION (?:public\.)?(?:"([^"]+)"|(\w+)) /) { |quoted, bare| tables.delete(quoted || bare) }
+
         { dialect: detect_sql_dialect(content), tables: tables }
       end
 
@@ -93,8 +96,9 @@ module RailsAiContext
         body.each_line do |line|
           line = line.strip.chomp(",")
           case line
-          when /\ACONSTRAINT\s+[`"]?\w+[`"]?\s+FOREIGN KEY\s*\([`"]?(\w+)[`"]?\)\s*REFERENCES\s+[`"]?(\w+)[`"]?\s*\([`"]?(\w+)[`"]?\)/i
-            table[:foreign_keys] << { from_table: table_name, to_table: $2, column: $1, primary_key: $3 }
+          when /\ACONSTRAINT\s+[`"]?\w+[`"]?\s+FOREIGN KEY\s*\(([^)]*)\)\s*REFERENCES\s+[`"]?(\w+)[`"]?\s*\(([^)]*)\)/i
+            columns, to, keys = $1, $2, $3
+            table[:foreign_keys] << SchemaConventions.foreign_key_entry(table_name, to, columns.scan(/\w+/), keys.scan(/\w+/))
           when /\A(UNIQUE\s+)?(?:KEY|INDEX)\s+[`"](\w+)[`"]\s*(\(.*)/i
             # Captured to locals first: the parsing below runs more regexes,
             # which would clobber $~ before the hash literal reads it.

data/lib/rails_ai_context/introspectors/view_template_introspector.rb

@@ -368,7 +368,7 @@ module RailsAiContext
         refs = []
         # The partial or template a render call names, positionally or as a
         # keyword anywhere in its arguments, with or without parentheses.
-        render_arguments(content).each do |args|
+        self.class.render_calls(content).each do |_, args|
           named = [ args[RENDER_POSITIONAL, 2], *top_level(args).scan(RENDER_NAMED).flatten ].compact
           # An interpolated name is decided at runtime, not a partial on disk.
           refs.concat(named.select { |name| name.match?(PARTIAL_NAME) })
@@ -388,28 +388,21 @@ module RailsAiContext
         refs.uniq
       end
 
-      # Each render call's argument text: its balanced parentheses, or the rest of
-      # the line and every line a trailing comma continues onto.
-      def render_arguments(content)
+      # Each render call as [offset, argument text]: its balanced parentheses,
+      # or the rest of the line and every line a trailing comma continues onto.
+      def self.render_calls(content)
         content.to_enum(:scan, RENDER_CALL).map do
-          rest = content[Regexp.last_match.end(0)..]
+          at = Regexp.last_match.end(0)
+          rest = content[at..]
           open = rest[/\A\s*\(/]
-          next continued_line(rest) unless open
+          next [ at, continued_line(rest) ] unless open
 
           span = RailsAiContext::Brackets.span(rest, open.length - 1, comments: :ruby)
-          span ? span[1...-1] : rest[open.length..]
+          [ at, span ? span[1...-1] : rest[open.length..] ]
         end
       end
 
-      # The argument text with every nested (), [] and {} group dropped, so a
-      # `template:` inside `locals: {...}` or `Foo.new(...)` is not the call's.
-      def top_level(args)
-        kept = +""
-        RailsAiContext::Brackets.each_top_level(args, comments: :ruby) { |piece, kind| kept << piece unless %i[group comment].include?(kind) }
-        kept
-      end
-
-      def continued_line(text)
+      def self.continued_line(text)
         lines = []
         text.each_line do |line|
           lines << line
@@ -417,6 +410,15 @@ module RailsAiContext
         end
         lines.join
       end
+      private_class_method :continued_line
+
+      # The argument text with every nested (), [] and {} group dropped, so a
+      # `template:` inside `locals: {...}` or `Foo.new(...)` is not the call's.
+      def top_level(args)
+        kept = +""
+        RailsAiContext::Brackets.each_top_level(args, comments: :ruby) { |piece, kind| kept << piece unless %i[group comment].include?(kind) }
+        kept
+      end
 
       def extract_stimulus_refs(content)
         self.class.stimulus_refs(content)

data/lib/rails_ai_context/migration_status.rb

@@ -21,7 +21,12 @@ module RailsAiContext
       return nil unless defined?(ActiveRecord::Base)
 
       context = migration_context(migrate_dir)
-      context.open.pending_migrations.map { |m| { version: m.version.to_s, name: m.name } }
+      begin
+        context.open.pending_migrations.map { |m| { version: m.version.to_s, name: m.name } }
+      rescue ActiveRecord::MigrationError
+        # A future or duplicate version stops Rails loading the directory; the applied set still answers.
+        PendingMigrations.for(migrate_dir: migrate_dir, applied: context.get_all_versions)
+      end
     rescue => e
       RailsAiContext.debug_fail(e, nil, label: "MigrationStatus.pending")
     end

data/lib/rails_ai_context/pending_migrations.rb

@@ -25,9 +25,10 @@ module RailsAiContext
       unapplied.map { |m| { version: m[:version], name: m[:name] } }
     end
 
-    # The connection's answer; nil when there is no database to ask.
+    # The connection's answer; nil when there is no database to ask. The schema
+    # and migrations sections both ask, so a run queries once.
     def live(migrate_dir)
-      MigrationStatus.pending(migrate_dir)
+      RunCache.fetch([ :pending_migrations, migrate_dir.to_s ]) { MigrationStatus.pending(migrate_dir) }
     end
 
     # Each secondary database keeps its own migrate directory, so a secondary

data/lib/rails_ai_context/portable_path.rb

@@ -80,6 +80,20 @@ module RailsAiContext
       relative unless relative.start_with?(File::SEPARATOR)
     end
 
+    # For free text such as an exception message, which names a file by its
+    # absolute path, often through the resolved form of the root (/private/tmp).
+    def relativize_text(text, root)
+      root = root.to_s
+      return text.to_s if root.empty?
+
+      real = File.realpath(root) rescue root
+      prefixes = [ root, real ].uniq.sort_by { |prefix| -prefix.length }.map { |prefix| Regexp.escape(prefix) }
+      alternation = prefixes.join("|")
+      text.to_s
+        .gsub(%r{(\A|[\s"'`(:\[=,])(?:#{alternation})/}, '\1')
+        .gsub(%r{(\A|[\s"'`(:\[=,])(?:#{alternation})(?=\z|[\s"'`)\],;:])}, '\1.')
+    end
+
     def relativize_all(paths, root)
       Array(paths).map { |path| relativize(path, root) }.uniq
     end