rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/gem_lock.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require "set"
+require "pathname"
 require_relative "safe_file"
+require_relative "safe_path"
+require_relative "polyfill/data"
 
 module RailsAiContext
   # Which gems an app resolved, read once per lockfile, and the one answer
@@ -15,28 +18,50 @@ module RailsAiContext
     MAX_SIZE = 5 * 1024 * 1024
     SPEC_LINE = /\A {4}(\S+) \(([^)]+)\)\s*\z/
     DEPENDENCY_LINE = /\A {2}(\S+?)!?(?: \(.*\))?\s*\z/
-    RUBY_LINE = /\A\s+ruby (\S+)/
+    # Bundler writes a non-CRuby engine after the version: "ruby 3.1.4p0 (jruby 9.4.8.0)".
+    RUBY_LINE = /\A\s+ruby (\S+)(?: \((\S+) ([^)]+)\))?/
     REMOTE_LINE = /\A {2}remote: (.+?)\s*\z/
-    GEMFILE_RUBY_LINE = /^\s*ruby\s+(["'])([^"']+)\1/
     PLAIN_VERSION = /\A\d+(?:\.\d+)*\S*\z/
     TOOL_VERSIONS_RUBY = /^ruby[ \t]+(\S+)/
-    # Bundler's order: what the lockfile resolved, what the Gemfile asked for, then the
-    # version-manager files the shell picks when neither says.
-    RUBY_SOURCES = [ "Gemfile.lock", "Gemfile", ".ruby-version", ".tool-versions" ].freeze
+    # Version managers write another engine as "<engine>-<version>", as ruby-build names it.
+    ENGINE_PREFIXED = /\A([a-z][a-z+]*)-(\d\S*)\z/
+    ENGINE_NAMES = {
+      "jruby" => "JRuby", "truffleruby" => "TruffleRuby", "truffleruby+graalvm" => "TruffleRuby+GraalVM",
+      "mruby" => "mruby", "rbx" => "Rubinius"
+    }.freeze
+    # mise's project files, highest precedence first (mise docs, configuration).
+    MISE_FILES = [ "mise.local.toml", "mise.toml", ".mise.toml", "mise/config.toml", ".mise/config.toml", ".config/mise.toml",
+                   ".config/mise/config.toml" ].freeze
+    VERSION_FILES = [ ".ruby-version", ".tool-versions", *MISE_FILES ].freeze
+    MISE_TOOLS = /^[ \t]*\[tools\][ \t]*$(.*?)(?=^[ \t]*\[|\z)/m
+    # ruby = "3.3.6", ruby = ["3.3.6", ...] or ruby = { version = "3.3.6" }
+    MISE_RUBY = /^[ \t]*["']?ruby["']?[ \t]*=[ \t]*(?:\[[ \t]*|\{[^}\n]*?version[ \t]*=[ \t]*)?["']([^"'\n]+)["']/
 
     class Spec
-      # `remote:` of each PATH section, as the lockfile writes it.
-      attr_reader :ruby_versions, :reason, :path_remotes
+      # `ruby_engine` is a non-CRuby engine with its own version ("JRuby 9.4.8.0"); `outside_gemfile` is never read.
+      attr_reader :ruby_versions, :ruby_engine, :reason, :path_remotes, :outside_gemfile
+      # With no lockfile, the gems the Gemfile names; nil when it names only some of them.
+      attr_reader :gemfile_gems
 
-      def initialize(versions, ruby_versions: {}, reason: nil, absent: false, direct: nil, path_remotes: [])
+      def initialize(versions, ruby_versions: {}, ruby_engine: nil, reason: nil, absent: false, direct: nil, path_remotes: [],
+                     outside_gemfile: nil, no_repo: false, gemfile_gems: nil)
         @versions = versions
+        @gemfile_gems = gemfile_gems
+        @outside_gemfile = outside_gemfile
+        @no_repo = no_repo
         @path_remotes = path_remotes
         @ruby_versions = ruby_versions
+        @ruby_engine = ruby_engine
         @reason = reason
         @absent = absent
         @direct = direct || Set.new
       end
 
+      # Why the bundle config/boot.rb names went unread, worded the same by every tool.
+      def unread_bundle
+        GemLock.unread_bundle(@outside_gemfile, @no_repo) if @outside_gemfile
+      end
+
       # Several files may name a version and they often disagree, so the source is kept too.
       def ruby_version
         @ruby_versions.values.first
@@ -85,46 +110,161 @@ module RailsAiContext
       end
     end
 
+    # `dir` holds the Gemfile and lockfile; `trusted` is the tree a path gem of theirs must stay
+    # inside; `outside` names a bundle config/boot.rb points at that is never read, `no_repo` says no git repository holds the app.
+    Bundle = Data.define(:lockfile, :gemfile, :lock_label, :gemfile_label, :dir, :trusted, :outside, :no_repo)
+
     MUTEX = Mutex.new
     CACHE = {}
     private_constant :MUTEX, :CACHE
 
     module_function
 
+    # Bundler looks for gems.rb before Gemfile.
+    def gemfile_name(root)
+      File.file?(File.join(root.to_s, "gems.rb")) ? "gems.rb" : "Gemfile"
+    end
+
+    # gems.rb locks to gems.locked, Gemfile to Gemfile.lock.
+    def lockfile_name(root)
+      gemfile_name(root) == "gems.rb" ? "gems.locked" : "Gemfile.lock"
+    end
+
     def for(root)
       root = root.to_s
-      path = File.join(root, "Gemfile.lock")
-      gemfile = File.join(root, "Gemfile")
-      stamp = RUBY_SOURCES.map { |name| mtime(File.join(root, name)) }
+      bundle = bundle(root)
+      stamp = [ bundle.lockfile, bundle.gemfile, File.join(root, "config/boot.rb"),
+                *VERSION_FILES.map { |name| File.join(root, name) } ].map { |file| file && mtime(file) } << loaded?
+      stamp << Introspectors::GemfileGems.stamps(bundle) if loaded?
 
       MUTEX.synchronize do
-        cached = CACHE[path]
+        cached = CACHE[root]
         return cached[:spec] if cached && cached[:stamp] == stamp
 
         # Which gems resolved and which Ruby the app declares are two facts,
         # and the Gemfile answers the second whether or not a lockfile answers
         # the first.
         spec = if stamp.first
-          parse(path, gemfile, root)
+          parse(bundle, root)
         else
-          Spec.new({}, ruby_versions: declared_ruby_versions(nil, root),
-                       reason: "No Gemfile.lock found", absent: true)
+          absent_spec(root, bundle)
         end
-        CACHE[path] = { stamp: stamp, spec: spec }
+        CACHE[root] = { stamp: stamp, spec: spec }
         spec
       end
     end
 
+    # The app's own Gemfile and lockfile, or, with no lockfile of its own, the
+    # bundle config/boot.rb points Bundler at (an engine's test/dummy).
+    def bundle(root)
+      root = root.to_s
+      own = Bundle.new(lockfile: File.join(root, lockfile_name(root)), gemfile: File.join(root, gemfile_name(root)),
+                       lock_label: lockfile_name(root), gemfile_label: gemfile_name(root), dir: root, trusted: root, outside: nil, no_repo: false)
+      return own if File.file?(own.lockfile)
+
+      boot_bundle(root, own) || own
+    end
+
+    # Read only inside the app's git repository, the trust its own Gemfile.lock has; anything else is named and left unread.
+    def boot_bundle(root, own)
+      target = boot_gemfile(root)
+      return nil unless target
+
+      real_root = File.realpath(root)
+      dir = File.dirname(target)
+      label = ->(file) { Pathname.new(File.join(dir, file)).relative_path_from(Pathname.new(real_root)).to_s }
+      gemfile = File.basename(target)
+      lockfile = gemfile == "gems.rb" ? "gems.locked" : "#{gemfile}.lock"
+      repo = SafePath.git_root(real_root)
+      unless repo && File.directory?(dir) && SafePath.contained?(File.realpath(dir), repo)
+        return own.with(lockfile: nil, outside: label.(gemfile), no_repo: repo.nil?)
+      end
+
+      Bundle.new(lockfile: inside_file(dir, lockfile), gemfile: inside_file(dir, gemfile), lock_label: label.(lockfile),
+                 gemfile_label: label.(gemfile), dir: File.realpath(dir), trusted: repo, outside: nil, no_repo: false)
+    rescue SystemCallError
+      nil
+    end
+    private_class_method :boot_bundle
+
+    # The BUNDLE_GEMFILE config/boot.rb sets, when it is outside the app root.
+    def boot_gemfile(root)
+      real_root = File.realpath(root)
+      real = File.realpath(File.join(real_root, "config/boot.rb"))
+      return nil unless SafePath.contained?(real, real_root)
+
+      result = ruby_parse(real) or return nil
+      relative, anchor = Introspectors::AstWalk.each(result.value).lazy.filter_map { |node| bundle_gemfile_path(node) }.first
+      return nil unless relative
+
+      # Relative to __FILE__ the path starts from boot.rb itself, one level below __dir__.
+      target = File.expand_path(relative, anchor == :file ? real : File.dirname(real))
+      target unless target.start_with?(SafePath.dir_prefix(real_root))
+    rescue SystemCallError
+      nil
+    end
+    private_class_method :boot_gemfile
+
+    # `ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)`, the line `rails new`
+    # and `rails plugin new` write, with `=` or `__FILE__` as older templates do.
+    def bundle_gemfile_path(node)
+      value = case node
+      when Prism::IndexOrWriteNode then node.value if env_index?(node.receiver, node.arguments&.arguments)
+      when Prism::CallNode then node.arguments&.arguments&.last if node.name == :[]= && env_index?(node.receiver, node.arguments&.arguments&.first(1))
+      end
+      return nil unless value.is_a?(Prism::CallNode) && value.name == :expand_path && value.receiver.is_a?(Prism::ConstantReadNode) &&
+                        value.receiver.name == :File
+
+      path, anchor = value.arguments&.arguments
+      return nil unless path.is_a?(Prism::StringNode) && value.arguments.arguments.size == 2
+
+      if anchor.is_a?(Prism::SourceFileNode) then [ path.unescaped, :file ]
+      elsif anchor.is_a?(Prism::CallNode) && anchor.name == :__dir__ && anchor.receiver.nil? then [ path.unescaped, :dir ]
+      end
+    end
+    private_class_method :bundle_gemfile_path
+
+    def env_index?(receiver, arguments)
+      receiver.is_a?(Prism::ConstantReadNode) && receiver.name == :ENV && arguments&.size == 1 && literal(arguments.first) == "BUNDLE_GEMFILE"
+    end
+    private_class_method :env_index?
+
+    # The file's real path when it exists and does not link out of its directory.
+    def inside_file(dir, name)
+      real = File.realpath(File.join(dir, name))
+      real if SafePath.contained?(real, File.realpath(dir))
+    rescue SystemCallError
+      nil
+    end
+    private_class_method :inside_file
+
+    def unread_bundle(outside, no_repo)
+      where = no_repo ? "and the app is in no git repository" : "outside the app's git repository"
+      "config/boot.rb points Bundler at `#{outside}`, #{where}"
+    end
+
+    def absent_spec(root, bundle)
+      reason = if bundle.outside
+        "No #{lockfile_name(root)} in the app; #{unread_bundle(bundle.outside, bundle.no_repo)}, so that bundle is not read"
+      else
+        "No #{bundle.lock_label} found"
+      end
+      facts = gemfile(bundle)
+      Spec.new({}, **declared_ruby(nil, root, bundle, facts), reason: reason, absent: true, outside_gemfile: bundle.outside,
+               no_repo: bundle.no_repo, gemfile_gems: facts[:gems])
+    end
+    private_class_method :absent_spec
+
     def mtime(path)
       File.mtime(path)
     rescue SystemCallError
       nil
     end
-    private_class_method :mtime
 
-    def parse(path, gemfile, root)
+    def parse(bundle, root)
+      path = bundle.lockfile
       content = SafeFile.read(path, max_size: MAX_SIZE)
-      return Spec.new({}, reason: "Gemfile.lock could not be read") unless content
+      return Spec.new({}, reason: "#{File.basename(path)} could not be read") unless content
 
       versions = {}
       direct = Set.new
@@ -152,52 +292,140 @@ module RailsAiContext
           # prerelease tag ("1.70.0-beta1") is dropped along with the platform.
           versions[match[1]] ||= match[2].split("-", 2).first
         elsif (match = line.match(RUBY_LINE)) && match[1].match?(PLAIN_VERSION)
-          ruby_version = match[1]
+          ruby_version = [ match[1], engine_name(match[2], match[3]) ]
         end
       end
       # An empty Gemfile still locks to a file with a specs: section, so no
       # gems is an answer there. A file without one is not a lockfile at all,
       # and answering it as an app with no gems denies every gem it holds.
-      return Spec.new({}, reason: "Gemfile.lock has no specs section") unless specs_section
+      return Spec.new({}, reason: "#{File.basename(path)} has no specs section") unless specs_section
 
-      Spec.new(versions, ruby_versions: declared_ruby_versions(ruby_version, root), direct: direct, path_remotes: path_remotes)
+      facts = gemfile(bundle)
+      Spec.new(versions, **declared_ruby(ruby_version, root, bundle, facts), direct: direct, path_remotes: path_remotes)
     end
     private_class_method :parse
 
-    # A lockfile without a RUBY VERSION section leaves the Gemfile as the only
-    # statement of the version. A requirement such as `ruby ">= 3.3.0"` names a
-    # range, not a version, so it is left unanswered rather than reported as one.
-    def gemfile_ruby_version(path)
+    # `gems` is nil when a call adds gems the Gemfile does not name (gemspec, a gem
+    # or eval_gemfile whose argument is not a literal, a file left unread).
+    def gemfile(bundle)
+      entries = gemfile_entries(bundle) or return { ruby: nil, gems: nil }
+
+      ruby = entries.find { |entry| entry[:type] == :ruby }
+      gems = entries.filter_map { |entry| entry[:name] if entry[:type] == :gem }.uniq unless entries.any? { |entry| entry[:type] == :unknown_gems }
+      { ruby: ruby && gemfile_ruby(ruby), gems: gems }
+    end
+    private_class_method :gemfile
+
+    # Before the gem loads, a plain walk of the one Gemfile; eval_gemfile is left unread.
+    def gemfile_entries(bundle)
+      return Introspectors::GemfileGems.read_bundle(bundle) if loaded?
+
+      result = ruby_parse(bundle.gemfile) or return nil
+      Introspectors::AstWalk.each(result.value).filter_map do |node|
+        next unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+
+        args = node.arguments&.arguments || []
+        case node.name
+        when :ruby
+          options = args.grep(Prism::KeywordHashNode).flat_map(&:elements).grep(Prism::AssocNode).to_h { |pair| [ literal(pair.key), literal(pair.value) ] }
+          { type: :ruby, version: literal(args.first), engine: options["engine"], engine_version: options["engine_version"] }
+        when :gem then args.first.is_a?(Prism::StringNode) ? { type: :gem, name: args.first.unescaped } : { type: :unknown_gems }
+        when :gemspec, :eval_gemfile then { type: :unknown_gems }
+        end
+      end
+    end
+    private_class_method :gemfile_entries
+
+    def loaded?
+      defined?(Introspectors::GemfileGems) ? true : false
+    end
+    private_class_method :loaded?
+
+    # AstCache once the gem is loaded; before the boot Prism alone, as AstCache's
+    # concurrent-ruby would load ahead of the app's bundle.
+    def ruby_parse(path)
+      return nil unless path
+      return AstCache.parse(File.realpath(path)) if loaded?
+
+      require "prism"
+      require_relative "introspectors/ast_walk"
       content = SafeFile.read(path, max_size: MAX_SIZE)
-      return nil unless content
+      content && Prism.parse(content)
+    rescue SystemCallError, ArgumentError, LoadError
+      nil
+    end
+    private_class_method :ruby_parse
 
-      declared = content[GEMFILE_RUBY_LINE, 2]
-      declared if declared&.match?(PLAIN_VERSION)
+    # A requirement such as `ruby ">= 3.3.0"` names a range, not a version, so it is left unanswered.
+    def gemfile_ruby(entry)
+      version = entry[:version]
+      [ version, engine_name(entry[:engine], entry[:engine_version]) ] if version&.match?(PLAIN_VERSION)
     end
-    private_class_method :gemfile_ruby_version
+    private_class_method :gemfile_ruby
 
-    def declared_ruby_versions(locked, root)
-      {
-        "Gemfile.lock" => locked,
-        "Gemfile" => gemfile_ruby_version(File.join(root, "Gemfile")),
-        ".ruby-version" => ruby_version_file(File.join(root, ".ruby-version")),
-        ".tool-versions" => tool_versions_ruby(File.join(root, ".tool-versions"))
+    def literal(node)
+      node.unescaped if node.is_a?(Prism::StringNode) || node.is_a?(Prism::SymbolNode)
+    end
+    private_class_method :literal
+
+    # Sources in Bundler's order; an engine's Ruby version comes only from its own source (JRuby 9.4 runs Ruby 3.1).
+    def declared_ruby(locked, root, bundle, facts)
+      declared = {
+        bundle.lock_label => locked,
+        bundle.gemfile_label => facts[:ruby],
+        ".ruby-version" => version_string(read_inside(root, ".ruby-version")&.strip),
+        ".tool-versions" => version_string(read_inside(root, ".tool-versions")&.[](TOOL_VERSIONS_RUBY, 1)),
+        **mise_ruby(root)
       }.compact
+      engine = declared.values.first&.last
+      declared = declared.first(1).to_h if engine
+      { ruby_versions: declared.transform_values(&:first).compact, ruby_engine: engine }
     end
-    private_class_method :declared_ruby_versions
+    private_class_method :declared_ruby
 
-    # `.ruby-version` is one line, written either bare or engine-prefixed.
-    def ruby_version_file(path)
-      declared = SafeFile.read(path, max_size: MAX_SIZE)&.strip&.sub(/\Aruby-/, "")
-      declared if declared&.match?(PLAIN_VERSION)
+    # SafePath's containment without its sensitive-pattern check, which needs
+    # the configuration: the CLI reads GemLock before loading it.
+    def read_inside(root, relative)
+      real = File.realpath(File.join(root, relative))
+      SafeFile.read(real, max_size: MAX_SIZE) if SafePath.contained?(real, File.realpath(root))
+    rescue SystemCallError
+      nil
     end
-    private_class_method :ruby_version_file
+    private_class_method :read_inside
 
-    def tool_versions_ruby(path)
-      content = SafeFile.read(path, max_size: MAX_SIZE)
-      declared = content&.[](TOOL_VERSIONS_RUBY, 1)
-      declared if declared&.match?(PLAIN_VERSION)
+    # The ruby tool of the mise file that wins, keyed by that file's name.
+    def mise_ruby(root)
+      MISE_FILES.each do |name|
+        content = read_inside(root, name)
+        tools = content&.[](MISE_TOOLS, 1)
+        declared = version_string(tools&.[](MISE_RUBY, 1))
+        return { name => declared } if declared
+      end
+      {}
+    end
+    private_class_method :mise_ruby
+
+    # "3.4.9" and "ruby-3.4.9" are CRuby; "jruby-9.4.8.0" names an engine
+    # version, not the Ruby version that engine implements, and a bare "jruby" its latest.
+    def version_string(declared)
+      return nil if declared.nil?
+
+      if (match = declared.match(ENGINE_PREFIXED)) && match[1] != "ruby"
+        [ nil, engine_name(match[1], match[2]) ]
+      elsif ENGINE_NAMES.key?(declared)
+        [ nil, engine_name(declared, nil) ]
+      else
+        version = declared.sub(/\Aruby-/, "")
+        [ version, nil ] if version.match?(PLAIN_VERSION)
+      end
+    end
+    private_class_method :version_string
+
+    def engine_name(engine, version)
+      return nil if engine.nil? || engine == "ruby"
+
+      [ ENGINE_NAMES.fetch(engine, engine), version ].compact.join(" ")
     end
-    private_class_method :tool_versions_ruby
+    private_class_method :engine_name
   end
 end

data/lib/rails_ai_context/git_ignore.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-
 module RailsAiContext
   # git's ignore-file rules (globs, anchoring, last match wins, negation) for
   # the doctor, and ripgrep's walk over a tree for the search fallback.
@@ -147,7 +145,7 @@ module RailsAiContext
       def global
         return @global if defined?(@global)
 
-        @global = source(@root, GitIgnore.global_excludes_path(@root))
+        @global = source(@root, GitIgnore.global_excludes_path)
       end
     end
 
@@ -169,15 +167,19 @@ module RailsAiContext
       nil
     end
 
-    # `core.excludesFile` as git resolves it from the app's directory, or the
-    # default git uses when it is unset.
-    def global_excludes_path(root)
-      configured, status = Open3.capture2("git", "config", "--get", "core.excludesFile", chdir: root)
-      configured = configured.to_s.strip
-      return File.expand_path(configured) if status.success? && !configured.empty?
-
+    # `core.excludesFile` as ripgrep 15 finds it: ~/.gitconfig, then the XDG
+    # git config, then git's default (ignore crate `gitconfig_excludes_path`).
+    def global_excludes_path
       xdg = ENV["XDG_CONFIG_HOME"].to_s
-      File.join(xdg.empty? ? File.join(Dir.home, ".config") : xdg, "git", "ignore")
+      config_dir = xdg.empty? ? File.join(Dir.home, ".config") : xdg
+      # A setting that is not UTF-8 is skipped, as ripgrep skips it.
+      configured = [ File.join(Dir.home, ".gitconfig"), File.join(config_dir, "git", "config") ].lazy.filter_map do |config|
+        path = File.file?(config) && File.binread(config)[/^\s*excludesfile\s*=\s*"?\s*(\S+?)\s*"?\s*$/i, 1]
+        path && path.force_encoding(Encoding::UTF_8).valid_encoding? ? path : nil
+      end.first
+      return File.expand_path(configured.gsub("~", Dir.home)) if configured
+
+      File.join(config_dir, "git", "ignore")
     rescue StandardError
       nil
     end

data/lib/rails_ai_context/hydrators/hydration_formatter.rb

@@ -26,14 +26,20 @@ module RailsAiContext
       def self.format_hint(hint)
         lines = []
         lines << "### #{hint.model_name} #{hint.confidence}"
-        lines << "**Table:** `#{hint.table_name}` (pk: `#{hint.primary_key}`)"
+        lines << if hint.embedded_in
+          "**Embedded in:** `#{hint.embedded_in}` (no collection of its own)"
+        elsif hint.collection
+          "**Collection:** `#{hint.table_name}` (key: `#{hint.primary_key}`)"
+        else
+          "**Table:** `#{hint.table_name}` (pk: `#{hint.primary_key}`)"
+        end
 
         if hint.columns.any?
           col_summary = hint.columns.first(10).map { |c|
             "`#{c[:name]}` #{c[:type]}#{'[]' if c[:array]}#{c[:null] == false ? ' NOT NULL' : ''}"
           }
           col_summary << "... #{hint.columns.size - 10} more" if hint.columns.size > 10
-          lines << "**Columns:** #{col_summary.join(', ')}"
+          lines << "**#{hint.collection ? 'Fields' : 'Columns'}:** #{col_summary.join(', ')}"
         end
 
         if hint.associations.any?

data/lib/rails_ai_context/hydrators/schema_hint_builder.rb

@@ -19,10 +19,13 @@ module RailsAiContext
         model_info = models_data[model_key]
         return nil unless model_info.is_a?(Hash)
 
-        table_name = model_info[:table_name]
-        table_data = schema_data.dig(:tables, table_name) if table_name
+        mongoid = model_info[:mongoid] == true
+        table_name = mongoid ? model_info[:collection] : model_info[:table_name]
+        table_data = Payload.model_table(schema_data, model_info) if table_name && !mongoid
 
-        columns = if table_data
+        columns = if mongoid
+          Array(model_info[:fields]).map { |field| { name: field[:name].to_s, type: field[:type] }.compact }
+        elsif table_data
           (table_data[:columns] || []).map do |col|
             { name: col[:name], type: col[:type], null: col[:null], array: col[:array] }.compact
           end
@@ -47,7 +50,7 @@ module RailsAiContext
           }.compact
         end
 
-        primary_key = table_data&.dig(:primary_key) || "id"
+        primary_key = mongoid ? "_id" : table_data&.dig(:primary_key) || "id"
 
         # A static record already carries [STATIC]; a booted one has no
         # confidence key, and a resolved table there is reflection-confirmed.
@@ -60,7 +63,9 @@ module RailsAiContext
           associations: associations,
           validations: validations,
           primary_key: Introspectors::SchemaConventions.primary_key_label(primary_key),
-          confidence: confidence
+          confidence: confidence,
+          collection: mongoid,
+          embedded_in: (model_info[:embedded_in] if mongoid)
         )
       end
     end

data/lib/rails_ai_context/introspector.rb

@@ -24,6 +24,7 @@ module RailsAiContext
       context = {
         app_name: app_name,
         ruby_version: ruby_version,
+        ruby_engine: ruby_engine,
         rails_version: rails_version,
         environment: environment_name,
         tier: RailsAiContext.static_tier? ? "static" : "booted",
@@ -203,6 +204,14 @@ module RailsAiContext
       GemLock.for(app.root).ruby_version || Confidence.unavailable("app declares none")
     end
 
+    # Nil for CRuby, else the engine and its own version ("JRuby 9.4.8.0").
+    def ruby_engine
+      return GemLock.for(app.root).ruby_engine if RailsAiContext.static_tier?
+      return nil if RUBY_ENGINE == "ruby"
+
+      [ GemLock::ENGINE_NAMES.fetch(RUBY_ENGINE, RUBY_ENGINE), RUBY_ENGINE_VERSION ].join(" ")
+    end
+
     def rails_version
       return Rails.version if defined?(Rails) && Rails.respond_to?(:version) && !RailsAiContext.static_tier?
 
@@ -210,7 +219,7 @@ module RailsAiContext
       # mid-sentence into files the user commits. An app can bundle railties
       # without the `rails` meta-gem and still be a Rails app at that version.
       lock = GemLock.for(app.root)
-      lock.version("rails") || lock.version("railties") || Confidence.unavailable("app not booted")
+      lock.version("rails") || lock.version("railties") || Confidence.unavailable(lock.outside_gemfile ? lock.reason : "app not booted")
     end
 
     def environment_name

data/lib/rails_ai_context/introspectors/action_mailbox_introspector.rb

@@ -2,45 +2,53 @@
 
 module RailsAiContext
   module Introspectors
-    # Discovers Action Mailbox setup: mailbox classes, routing patterns.
+    # Discovers Action Mailbox setup: mailbox classes and the routing that sends mail to them.
     class ActionMailboxIntrospector < Base
       extend StaticTier
       static_tier :files_only
 
+      BASE_FILE = "application_mailbox.rb"
+
       def call
+        mailboxes, routes = extract
         {
           installed: defined?(ActionMailbox) ? true : false,
-          mailboxes: extract_mailboxes
+          mailboxes: mailboxes,
+          routes: routes
         }
       end
 
       private
 
-      def extract_mailboxes
+      # Rails keeps one router for every mailbox, filled in load order, and the base loads first.
+      def extract
         dir = File.join(root, "app/mailboxes")
-        return [] unless Dir.exist?(dir)
-
-        Dir.glob(File.join(dir, "**/*.rb")).filter_map do |path|
-          relative = path.sub("#{dir}/", "")
-          next if relative == "application_mailbox.rb"
+        return [ [], [] ] unless Dir.exist?(dir)
 
-          name = File.basename(path, ".rb").camelize
-          ast_data = SourceIntrospector.walk(path, { mailbox: Listeners::MailboxRoutingListener })
+        paths = Dir.glob(File.join(dir, "**/*.rb")).sort_by { |path| [ path == File.join(dir, BASE_FILE) ? 0 : 1, path ] }
+        mailboxes = []
+        routes = []
+        paths.each do |path|
+          relative = path.delete_prefix("#{root}/")
+          results = SourceIntrospector.walk(path, { mailbox: Listeners::MailboxRoutingListener })[:mailbox]
 
-          routing = ast_data[:mailbox].select { |r| r[:type] == :routing }.map do |r|
-            { pattern: r[:pattern], action: r[:action] }
+          results.select { |r| r[:type] == :routing }.each do |r|
+            routes << { pattern: r[:pattern], mailbox: "#{r[:action].camelize}Mailbox", file: relative }
           end
+          next if path == File.join(dir, BASE_FILE)
 
-          callbacks = ast_data[:mailbox].select { |r| r[:type] == :callback }.map do |r|
-            { type: r[:callback_type], method: r[:method] }
-          end
-
-          entry = { name: name, file: relative, routing: routing }
+          entry = { name: path.delete_prefix("#{dir}/").delete_suffix(".rb").camelize, file: relative }
+          callbacks = results.select { |r| r[:type] == :callback }.map { |r| { type: r[:callback_type], method: r[:method] } }
           entry[:callbacks] = callbacks if callbacks.any?
-          entry
+          mailboxes << entry
         rescue => e
           RailsAiContext.debug_fail(e, nil, label: "extract_mailboxes")
-        end.compact.sort_by { |m| m[:name] }
+        end
+
+        mailboxes.each do |m|
+          m[:routed_from] = routes.select { |r| r[:mailbox] == m[:name] }.map { |r| r[:pattern] }
+        end
+        [ mailboxes.sort_by { |m| m[:name] }.map { |m| m.slice(:name, :file, :routed_from, :callbacks) }, routes ]
       end
     end
   end