rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/introspectors/convention_introspector.rb

@@ -284,7 +284,7 @@ module RailsAiContext
       # only a .keep file), and some apps keep only validator classes there
       # (one app keeps 37), so the claim needs one file that declares no class: a module.
       def concern_files_exist?(relative_path)
-        Dir.glob(File.join(root, relative_path, "**", "*.rb")).any? do |path|
+        ConcernPaths.files(File.join(root, relative_path), root).any? do |path|
           source = SafeFile.read(path)
           source && !DeclaredConstant.declares_class?(source, path_name: File.basename(path, ".rb").camelize)
         end

data/lib/rails_ai_context/introspectors/database_stats_introspector.rb

@@ -19,6 +19,10 @@ module RailsAiContext
       def call
         return { skipped: true, reason: "ActiveRecord not available" } unless defined?(ActiveRecord::Base)
 
+        # Connecting would create a SQLite file that is not there yet.
+        missing = DatabaseFile.missing(ActiveRecord::Base.connection_db_config)
+        raise missing if missing
+
         adapter = ActiveRecord::Base.connection.adapter_name.downcase
         case adapter
         when POSTGRES_ADAPTER
@@ -62,15 +66,23 @@ module RailsAiContext
         { adapter: "mysql", tables: tables, total_tables: tables.size }
       end
 
+      # SQLite keeps no row estimate a query can read without ANALYZE, and
+      # COUNT(*) walks the whole table on every introspection. A count that
+      # stops at the cap reads at most that many rows; a table past it is
+      # reported as at least the cap.
+      SQLITE_COUNT_CAP = 100_000
+
       def collect_sqlite_stats
         conn = ActiveRecord::Base.connection
         # Use conn.tables as authoritative list - never interpolate user input
         table_names = (conn.tables - SqliteVirtualTables.hidden(conn)).reject { |t| t.start_with?("ar_internal_metadata", "schema_migrations") }
 
         tables = table_names.map do |table|
-          count = conn.select_value("SELECT COUNT(*) FROM #{conn.quote_table_name(table)}").to_i
-          { table: table, approximate_rows: count }
-        end.sort_by { |t| -t[:approximate_rows] }
+          count = conn.select_value("SELECT COUNT(*) FROM (SELECT 1 FROM #{conn.quote_table_name(table)} LIMIT #{SQLITE_COUNT_CAP + 1})").to_i
+          entry = { table: table, approximate_rows: [ count, SQLITE_COUNT_CAP ].min }
+          entry[:at_least] = true if count > SQLITE_COUNT_CAP
+          entry
+        end.sort_by { |t| [ -t[:approximate_rows], t[:table] ] }
 
         { adapter: "sqlite", tables: tables, total_tables: tables.size }
       end

data/lib/rails_ai_context/introspectors/devops_introspector.rb

@@ -72,11 +72,13 @@ module RailsAiContext
           path = File.join(root, filename)
           next unless File.exist?(path)
 
+          # A command leaves the app as source does, through Redaction: `rails ai:context` writes
+          # it into .ai-context.json, which is committed (`--requirepass ...`, `DB_PASSWORD=...`).
           entries = (RailsAiContext::SafeFile.read(path) || "").lines.filter_map do |line|
             line.strip!
             next if line.empty? || line.start_with?("#")
             parts = line.split(":", 2)
-            { name: parts[0].strip, command: parts[1]&.strip } if parts.size == 2
+            { name: parts[0].strip, command: RailsAiContext::Redaction.redact_source_line(parts[1].strip, path: filename) } if parts.size == 2
           end
 
           { file: filename, entries: entries } if entries.any?

data/lib/rails_ai_context/introspectors/eager_load.rb

@@ -6,36 +6,120 @@ module RailsAiContext
     # did not eager load. eager_load_dir stops at the first unloadable file
     # and raises for a directory another loader owns, so both fall back to
     # loading one constant at a time; a file that cannot load costs itself.
+    #
+    # A file Ruby cannot compile is never required, and neither is one whose
+    # class body names its constant, since loading that one autoloads it:
+    # Prism reads each file the loader has not loaded yet first, about a
+    # tenth of a millisecond a file, and a file is read again only once its
+    # stat changes. Requiring one raised a SyntaxError out of Ruby's
+    # compiler, and with web-console in the bundle (bindex's raise hook)
+    # that crashed Ruby in about half the runs.
     module EagerLoad
+      # File => [stat, answer]: whether it compiles, and the constants its
+      # class body names. After a reload only the files edited since are
+      # read again.
+      SYNTAX = Concurrent::Map.new
+      CONSTANTS = Concurrent::Map.new
+
+      # File => [mtime, reason] for each file a note was written for, so a
+      # file left broken is noted once, not at every rebuild of the caches.
+      NOTED = Concurrent::Map.new
+
       module_function
 
+      # Returns the files left out, by real path, each with why.
       def dir(root, kind:)
-        return if Rails.application.config.eager_load
+        return {} if Rails.application.config.eager_load
 
         dirs = PathResolver.dirs_for(root, kind) + PathResolver.enclosing_engine_roots(root).map { |engine| File.join(engine, kind) }
-        dirs.select { |path| Dir.exist?(path) }.uniq.each { |path| load_dir(path) }
+        left_out = dirs.select { |path| Dir.exist?(path) }.uniq.each_with_object({}) { |path, found| found.merge!(load_dir(path)) }
+        RunCache.fetch([ :eager_load_skipped ]) { {} }.merge!(left_out)
+        left_out
       rescue StandardError, ScriptError => e
-        RailsAiContext.debug_fail(e, nil, label: "eager load of #{kind}")
+        RailsAiContext.debug_fail(e, {}, label: "eager load of #{kind}")
+      end
+
+      # Why this run left a file unloaded, by its real path, or nil: it does
+      # not compile, or its class body names a constant from one that does
+      # not. Outside a run, or for a file no walk here reached, only the
+      # file's own syntax is asked, and only if it is not loaded already.
+      def skipped(file)
+        RunCache.fetch([ :eager_load_skipped ]) { {} }[file] ||
+          (syntax_error(file) unless $LOADED_FEATURES.include?(file))
+      end
+
+      # The constant a name resolves to, loading what it must as constantize
+      # does, or nil for a name nothing defines. A tool that looks an app class
+      # up by name keeps the rule the walks keep: a file this module leaves
+      # out is never required, and the answer is then the block's, given why,
+      # or nil.
+      def constant(name)
+        name.to_s.delete_prefix("::").split("::").reduce(Object) do |scope, segment|
+          return nil unless scope.is_a?(Module) && scope.const_defined?(segment, false)
+
+          file = scope.autoload?(segment, false)
+          reason = file && left_out(file)
+          return (yield reason if block_given?) if reason
+
+          scope.const_get(segment, false)
+        end
+      rescue NameError
+        nil
+      end
+
+      # Why requiring a file now would raise out of Ruby's compiler, or nil:
+      # what a walk this run found, the file's own syntax error, else what a
+      # walk of the autoload root holding it finds - a file its class body
+      # needs that does not compile, however far down.
+      def left_out(file)
+        found = skipped(file)
+        return found if found || $LOADED_FEATURES.include?(file)
+
+        loader = Rails.autoloaders.main
+        root = loader.dirs.select { |dir| file.start_with?("#{dir}/") }.max_by(&:length) if loader.respond_to?(:dirs)
+        root && unloadable(root, Dir.glob(File.join(root, "**/*.rb")).sort)[file]
+      end
+
+      # Prism's first error in a file, worded as Ruby words a SyntaxError
+      # ("app/models/post.rb:4: syntax error, unexpected 'end'; ..."), or nil
+      # when the running Ruby's grammar takes it - or when Prism cannot read
+      # it, and the require decides as it always did.
+      def syntax_error(file)
+        per_file(SYNTAX, file) do
+          next nil if AstCache.parse_success?(file, ruby: RUBY_VERSION)
+
+          error = AstCache.parse(file, ruby: RUBY_VERSION).errors.first
+          error && "#{relative(file)}:#{error.location.start_line}: syntax error, #{error.message}"
+        end
+      rescue StandardError
+        nil
       end
 
       # eager_load_dir returns silently for a directory the loader manages
       # but does not eager load, so the per-constant walk always follows: a
       # constant already loaded is a hash lookup, and one that is not gets
-      # loaded here. A file that cannot load costs itself.
+      # loaded here. eager_load_dir would require the files left out, so it
+      # runs only when there are none.
       def load_dir(path)
+        files = Dir.glob(File.join(path, "**/*.rb")).sort
+        left_out = unloadable(path, files)
+        load_whole(path) if left_out.empty?
+        load_individually(path, files - left_out.keys)
+        left_out.transform_keys { |file| real(file) }
+      end
+
+      def load_whole(path)
         loader = Rails.autoloaders.main
         loader.eager_load_dir(path) if loader.respond_to?(:eager_load_dir)
       rescue StandardError, ScriptError => e
         RailsAiContext.debug_fail(e, label: "eager_load_dir #{path}")
-      ensure
-        load_individually(path)
       end
 
       # The loader names the constant, not `camelize`: an app inflection
       # makes the two disagree, and a wrong name silently loads nothing.
-      def load_individually(path)
+      def load_individually(path, files)
         loader = Rails.autoloaders.main
-        Dir.glob(File.join(path, "**/*.rb")).sort.each do |file|
+        files.each do |file|
           cpath_for(loader, path, file).constantize
         rescue StandardError, ScriptError
           next
@@ -48,6 +132,8 @@ module RailsAiContext
       def files(records)
         loader = Rails.autoloaders.main
         records.each do |record|
+          next if skipped(record.path)
+
           names = [ expected_cpath(loader, record.path) ].compact
           names = DeclaredConstant.declarations(record.source).map(&:name) if names.empty?
           names = [ record.path_name ] if names.empty?
@@ -57,6 +143,110 @@ module RailsAiContext
         end
       end
 
+      # The files under `path` the loader has not loaded and must not load
+      # now, each with why: one Prism finds an error in, then each whose
+      # class body names a constant from one of those - an included concern,
+      # a superclass - and so on down. A file already loaded is a constant
+      # lookup, which compiles nothing, and is not read.
+      def unloadable(path, files)
+        loaded = $LOADED_FEATURES.to_set
+        pending = files.reject { |file| loaded.include?(file) }
+        found = pending.each_with_object({}) do |file, broken|
+          error = syntax_error(file)
+          broken[file] = error if error
+        end
+        return found if found.empty?
+
+        add_dependents(path, pending, found)
+        found.each { |file, reason| note(file, reason) }
+        found
+      end
+
+      # Each reason names the file that does not compile, however far down.
+      def add_dependents(path, pending, found)
+        loader = Rails.autoloaders.main
+        blocked = found.keys.to_h { |file| [ cpath_for(loader, path, file), file ] }
+        cause = found.keys.to_h { |file| [ file, file ] }
+        names = (pending - found.keys).to_h { |file| [ file, load_time_constants(file) ] }
+        loop do
+          added = names.filter_map do |file, refs|
+            next if found.key?(file)
+
+            cpath = refs.lazy.filter_map { |ref| blocker(blocked, ref) }.first
+            next unless cpath
+
+            by = blocked[cpath]
+            cause[file] = cause[by]
+            how = by == cause[by] ? "which does not compile" : "which needs a file that does not compile"
+            found[file] = "#{relative(file)} needs #{cpath}, #{how}: #{found[cause[by]]}"
+            blocked[cpath_for(loader, path, file)] = file
+          end
+          break if added.empty?
+        end
+      end
+
+      # The constants loading a file evaluates: what its code names outside
+      # method bodies and lambdas - a superclass, an included concern, the
+      # namespace it opens - each with the namespaces it is written under.
+      # Read once per file while one is broken, so the parse is not cached.
+      def load_time_constants(file)
+        per_file(CONSTANTS, file) do
+          names = []
+          visit = lambda do |node|
+            case node
+            when Prism::DefNode, Prism::LambdaNode then nil
+            when Prism::ConstantReadNode then names << node.name.to_s
+            when Prism::ConstantPathNode
+              parts = (node.full_name rescue node.slice).delete_prefix("::").split("::")
+              parts.each_index { |i| names << parts[0..i].join("::") }
+            else node.compact_child_nodes.each(&visit)
+            end
+          end
+          visit.call(AstCache.parse_uncached(File.read(file)).value)
+          names.uniq
+        end
+      rescue StandardError
+        []
+      end
+
+      # The block's answer for a file, kept while the file's stat holds. A
+      # file younger than AstCache::RACY_WINDOW is read every time: its stat
+      # may not show a rewrite yet.
+      def per_file(store, file)
+        stat = File.stat(file)
+        stamp = [ stat.mtime.to_i, stat.mtime.nsec, stat.size, stat.ino ] if stat.mtime < Time.now - AstCache::RACY_WINDOW
+        kept = stamp && store[file]
+        return kept[1] if kept && kept[0] == stamp
+
+        answer = yield
+        store[file] = [ stamp, answer ] if stamp
+        answer
+      end
+
+      # A name written inside a namespace can mean that namespace's constant,
+      # so a broken Admin::BaseController blocks a `< BaseController`.
+      def blocker(blocked, ref)
+        blocked.keys.find { |cpath| cpath == ref || cpath.end_with?("::#{ref}") }
+      end
+
+      def note(file, reason)
+        stamp = [ (File.mtime(file) rescue nil), reason ]
+        return if NOTED[file] == stamp
+
+        NOTED[file] = stamp
+        RailsAiContext.log_warn("[rails-ai-context] Left unloaded: #{reason}")
+      end
+
+      def relative(file)
+        PortablePath.relativize_text(file, Rails.root)
+      end
+
+      def real(file)
+        File.realpath(file)
+      rescue SystemCallError
+        file
+      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, and Zeitwerk before 2.6.9
       # cannot answer; its inflector, segment by segment as Zeitwerk itself
@@ -75,7 +265,9 @@ module RailsAiContext
       rescue Zeitwerk::Error
         nil
       end
-      private_class_method :load_dir, :load_individually, :cpath_for, :inflect, :expected_cpath
+      private_class_method :load_dir, :load_whole, :load_individually, :left_out, :unloadable, :add_dependents,
+                           :load_time_constants, :per_file, :blocker, :note, :relative, :real,
+                           :cpath_for, :inflect, :expected_cpath
     end
   end
 end

data/lib/rails_ai_context/introspectors/engine_introspector.rb

@@ -97,7 +97,7 @@ module RailsAiContext
         return "." if path == app.root.to_s
 
         relative = PortablePath.relativize("#{path}/", app.root).chomp("/")
-        relative unless relative.start_with?(File::SEPARATOR)
+        relative unless SafePath.absolute?(relative)
       end
 
       def discover_rails_engines

data/lib/rails_ai_context/introspectors/env_config_introspector.rb

@@ -27,7 +27,7 @@ module RailsAiContext
 
       # @return [Hash] per-environment config summary
       def call
-        files = Dir.glob(File.join(root, "config", "environments", "*.rb")).sort.filter_map do |path|
+        files = Dir.glob(File.join(root, "config", "environments", "*.rb")).sort.reject { |path| PathResolver.linked_out?(path, root) }.filter_map do |path|
           summarize(path)
         end
 

data/lib/rails_ai_context/introspectors/env_references.rb

@@ -36,7 +36,9 @@ module RailsAiContext
           next if !ruby?(path) && !source.include?("<%")
 
           refs = references(ruby_source(path, source))
-          refs = refs.map { |ref| ref.except(:default).merge(default_unread: true) } if names_only
+          # Whether a site has a default is its shape, not its value: a site
+          # with none still raises or reads nil, and says so.
+          refs = refs.map { |ref| ref.key?(:default) ? ref.except(:default).merge(default_unread: true) : ref } if names_only
           found[path] = refs if refs.any?
         end
       rescue SystemCallError => e
@@ -77,10 +79,17 @@ module RailsAiContext
         script?(path) || path.end_with?(*RUBY_EXTENSIONS)
       end
 
+      # A YAML comment line still runs through ERB, but what its tag writes
+      # goes with the comment: database.yml's `#   url: <%= ENV["MY_APP_DATABASE_URL"] %>`
+      # names a variable nothing uses.
+      YAML_COMMENT_LINE = /^[ \t]*#.*$/
+
       # ERB tags carry the Ruby of a `.yml` or `.erb` file.
       def ruby_source(path, source)
         return source if ruby?(path)
 
+        # Blanked, not dropped, so every line keeps its number.
+        source = source.gsub(YAML_COMMENT_LINE) { |line| " " * line.size } if path.end_with?(".yml", ".yaml")
         RailsAiContext::ErbSource.ruby_in_place(source)
       end
 

data/lib/rails_ai_context/introspectors/frontend_framework_introspector.rb

@@ -197,7 +197,7 @@ module RailsAiContext
       end
 
       def component_files(dir, matcher)
-        FileWalk.each_file(dir, skip: scan_skip_dirs).select { |path| File.basename(path).match?(matcher) }
+        FileWalk.each_file(dir, skip: scan_skip_dirs, root: root.to_s).select { |path| File.basename(path).match?(matcher) }
       end
 
       def scan_skip_dirs

data/lib/rails_ai_context/introspectors/gem_introspector.rb

@@ -179,6 +179,18 @@ module RailsAiContext
         "webauthn"        => { category: :auth, note: "WebAuthn/passkey registration and authentication." }
       }.freeze
 
+      # Notable gems that run inside the app whichever gem brings them in: one that ships a Rails::Railtie or
+      # Rails::Engine, and OmniAuth, the Rack middleware a gem pulls in only to mount it in the app.
+      IN_APP_GEMS = %w[
+        action_policy activeadmin administrate alba apipie-rails avo bullet carrierwave clearance cocoon cssbundling-rails
+        datadog delayed_job devise devise-jwt doorkeeper factory_bot_rails falcon figaro flipper good_job grape graphql
+        hotwire-native-rails importmap-rails inertia_rails jbuilder jsbundling-rails jsonapi-serializer kaminari kredis lockbox
+        lookbook madmin mission_control-jobs mongoid motor-admin neighbor newrelic_rpm noticed omniauth paper_trail pg_search
+        propshaft pundit rack-attack react-rails rodauth-rails rolify rspec-rails rswag-api rswag-ui sentry-rails sidekiq
+        simple_form skylight solid_cable solid_cache solid_errors solid_queue sorcery stimulus-rails
+        stripe tailwindcss-rails trestle turbo-rails view_component will_paginate
+      ].to_set.freeze
+
       # @return [Hash] gem analysis
       def call
         lock = RailsAiContext::GemLock.for(root)
@@ -220,7 +232,8 @@ module RailsAiContext
           if opts[:path]
             { name: entry[:name], source: "path", location: opts[:path].to_s }
           elsif opts[:git]
-            { name: entry[:name], source: "git", location: opts[:git].to_s }
+            # A private repository's URL may carry its credentials (`https://user:token@host/...`).
+            { name: entry[:name], source: "git", location: RailsAiContext::Redaction.redact_source_line(opts[:git].to_s) }
           end
         end
       rescue => e
@@ -242,14 +255,9 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, {}, label: "detect_gem_groups")
       end
 
-      # Every Rails app resolves minitest through activesupport, so presence
-      # in the lockfile said nothing about the app's own test suite.
-      INDIRECT_BY_DEFAULT = %w[minitest].freeze
-
       def detect_notable_gems(lock)
         NOTABLE_GEMS.filter_map do |gem_name, info|
-          next unless lock.present?(gem_name)
-          next if INDIRECT_BY_DEFAULT.include?(gem_name) && !app_uses_indirect?(gem_name, lock)
+          next unless lock.present?(gem_name) && app_uses?(gem_name, lock)
 
           {
             name: gem_name,
@@ -260,10 +268,15 @@ module RailsAiContext
         end
       end
 
-      def app_uses_indirect?(gem_name, lock)
-        return true if lock.direct?(gem_name)
+      # A lockfile also holds what other gems depend on: Rails resolves every framework and
+      # loads only those it is asked for, and activesupport pulls in minitest.
+      def app_uses?(gem_name, lock)
+        return true if lock.direct?(gem_name) || IN_APP_GEMS.include?(gem_name)
+        return Dir.exist?(File.join(root, "test")) if gem_name == "minitest"
+        # Rails 7 left Sprockets out of rails/all and the rails gem: a gem that pulls it in since loads it.
+        return true if gem_name == "sprockets-rails" && lock.version("rails") && Gem::Version.new(lock.version("rails")) >= Gem::Version.new("7.0")
 
-        gem_name == "minitest" ? Dir.exist?(File.join(root, "test")) : false
+        lock.present?("rails") && AppKind.loads_framework?(root, gem_name)
       end
 
       # What the app does with Redis is a question the app answers. The fixed

data/lib/rails_ai_context/introspectors/grape_endpoints.rb

@@ -39,7 +39,7 @@ module RailsAiContext
       def read(root)
         classes = {}
         DIRS.each do |dir|
-          FileWalk.each_file(File.join(root, dir)).select { |path| path.end_with?(".rb") }.sort.each do |path|
+          FileWalk.each_file(File.join(root, dir), root: root).select { |path| path.end_with?(".rb") }.sort.each do |path|
             relative = path.delete_prefix("#{root}/")
             source, = SafePath.read(relative, under: root)
             next if source.nil? || source.empty?

data/lib/rails_ai_context/introspectors/habtm_join_tables.rb

@@ -48,7 +48,7 @@ module RailsAiContext
 
       def ruby_files(root)
         ([ root ] + PathResolver.code_roots(root)).uniq.flat_map do |dir|
-          %w[app lib].flat_map { |sub| FileWalk.each_file(File.join(dir, sub), skip: SKIP).select { |f| f.end_with?(".rb") } }
+          %w[app lib].flat_map { |sub| FileWalk.each_file(File.join(dir, sub), skip: SKIP, root: root).select { |f| f.end_with?(".rb") } }
         end.uniq
       end
 

data/lib/rails_ai_context/introspectors/helper_names.rb

@@ -15,7 +15,7 @@ module RailsAiContext
         names = Set.new
         included = []
         PathResolver.dirs_for(root, "app/helpers").each do |dir|
-          FileWalk.each_file(dir).select { |path| path.end_with?(".rb") }.each do |path|
+          FileWalk.each_file(dir, root: root).select { |path| path.end_with?(".rb") }.each do |path|
             source = RailsAiContext::SafeFile.read(path)
             next if source && !view_helper?(source, path, dir)
 

data/lib/rails_ai_context/introspectors/i18n_introspector.rb

@@ -140,7 +140,7 @@ module RailsAiContext
         # says nothing about this one. The rest are read only when the running
         # one is absent, where reading nothing would be the worse answer.
         env = ENV["RAILS_ENV"] || "development"
-        all_environments = Dir.glob(File.join(root, "config", "environments", "*.rb")).sort
+        all_environments = Dir.glob(File.join(root, "config", "environments", "*.rb")).sort.reject { |path| PathResolver.linked_out?(path, root) }
         running = all_environments.select { |path| File.basename(path, ".rb") == env }
         environments = running.any? ? running.map { |path| [ path, false ] }
                                     : all_environments.map { |path| [ path, true ] }
@@ -174,7 +174,7 @@ module RailsAiContext
                                  .map { |entry| entry.merge(spelling: :config) } +
                   walked[:i18n].select { |entry| I18N_AVAILABLE_LOCALES.include?(entry[:path]) }
                                .map { |entry| entry.merge(spelling: :i18n) }
-        entries.select { |entry| entry[:assignment] }.sort_by { |entry| entry[:location] }
+        entries.select { |entry| entry[:assignment] }.sort_by.with_index { |entry, i| [ entry[:location], i ] }
       end
 
       # One walk per config file for every i18n setting read from it, and none for
@@ -357,7 +357,7 @@ module RailsAiContext
       # The files Rails loads: config/locales by its glob, then what config.i18n.load_path adds.
       def locale_file_paths
         @locale_file_paths ||= begin
-          defaults = locales_dir ? Dir.glob(File.join(locales_dir, RAILS_LOCALE_GLOB)) : []
+          defaults = locales_dir ? Dir.glob(File.join(locales_dir, RAILS_LOCALE_GLOB)).reject { |path| PathResolver.linked_out?(path, root) } : []
           (defaults + load_path_files).uniq.sort
         end
       end

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -177,7 +177,7 @@ module RailsAiContext
           @queue_as_walks[file] = begin
             real = File.realpath(file)
             root = app.root.to_s
-            if SourceScan.under_root?(file, real, root, app_root_real)
+            if SourceScan.under_root?(file, real, root, app_root_real) && !PathResolver.linked_out?(file, root)
               relative = SourceScan.relative_file(file, real, root, app_root_real)
               job_candidates.values.find { |candidate| candidate.file == relative }&.ast ||
                 (source = SafeFile.read(file)) && SourceIntrospector.walk_source(source, QUEUE_AS_LISTENERS)
@@ -965,7 +965,8 @@ module RailsAiContext
       end
 
       def app_config_files
-        @app_config_files ||= MAILER_CONFIG_GLOBS.flat_map { |glob| Dir.glob(File.join(app.root.to_s, glob)).sort }.map { |path| path.delete_prefix("#{app.root}/") }
+        @app_config_files ||= MAILER_CONFIG_GLOBS.flat_map { |glob| Dir.glob(File.join(app.root.to_s, glob)).sort }
+          .reject { |path| PathResolver.linked_out?(path, app.root) }.map { |path| path.delete_prefix("#{app.root}/") }
       end
 
       def mailer_config_files
@@ -1253,15 +1254,16 @@ module RailsAiContext
       end
 
       # The file a loaded class was read from, root-relative; nil when the
-      # constant has no source location or it lies outside the app. Compared
-      # as real paths, the way app_defined? does, so a symlinked root keeps it.
+      # constant has no source location, it lies outside the app, or a symlink
+      # carries it out of the app. Compared as real paths, the way app_defined?
+      # does, so a symlinked root keeps it.
       def source_file_for(klass)
         location = Object.const_source_location(klass.name)&.first
         return nil unless location
 
         real = File.realpath(location)
         root = app.root.to_s
-        return nil unless SourceScan.under_root?(location, real, root, app_root_real)
+        return nil unless SourceScan.under_root?(location, real, root, app_root_real) && !PathResolver.linked_out?(location, root)
 
         SourceScan.relative_file(location, real, root, app_root_real)
       rescue NameError, ArgumentError, TypeError, SystemCallError
@@ -1301,7 +1303,7 @@ module RailsAiContext
 
       def channel_source(channel)
         path = channel_absolute_path(channel)
-        return nil unless path && File.exist?(path)
+        return nil unless path && File.exist?(path) && !PathResolver.linked_out?(path, app.root)
         RailsAiContext::SafeFile.read(path)
       end
 

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

@@ -198,14 +198,11 @@ module RailsAiContext
           end
         end
 
-        # The source of a call's default: option, for a value no literal carries.
-        def default_source(node)
-          value = default_node(node)
-          value && NodeSource.text(value)
-        end
-
-        def proc_default?(node)
-          proc_argument?(default_node(node))
+        # A call's default: for a value no literal carries: its source, and whether it is a proc.
+        # key: reads create_table's default for its implicit key.
+        def default_fields(node, key: false)
+          value = key ? key_default_node(node) : default_node(node)
+          { default_source: value && NodeSource.text(value), default_proc: proc_argument?(value) }
         end
 
         # `-> {}`, `lambda {}`, `proc {}` or `Proc.new {}`.
@@ -219,6 +216,13 @@ module RailsAiContext
           arg.name == :new && (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) && constant_path_string(receiver) == "Proc"
         end
 
+        # The default create_table gives its implicit key: an `id: { default: }` over its own `default:`.
+        def key_default_node(node)
+          id = extract_keyword_nodes(node)[:id]
+          inner = id.elements.find { |e| e.is_a?(Prism::AssocNode) && extract_key(e.key) == :default } if id.is_a?(Prism::HashNode)
+          inner&.value || default_node(node)
+        end
+
         def default_node(node)
           args = node.arguments&.arguments || []
           assoc = args.grep(Prism::KeywordHashNode)