rails-ai-context 5.30.2 → 5.32.0

data/docs/TOOLS.md

@@ -111,7 +111,7 @@ Method-aware code extraction with surrounding class context. Every line returned
 
 ### `rails_analyze_feature`
 
-Full-stack feature analysis: models + controllers + routes + services + jobs + views + tests in one call.
+Full-stack feature analysis: models + controllers + routes + services + admin resources + jobs + views + tests in one call.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -130,7 +130,12 @@ Composite context: schema + model + controller + routes + views for a resource.
 
 ### `rails_onboard`
 
-Narrative app walkthrough for getting up to speed.
+Narrative app walkthrough for getting up to speed. It ends with the app's custom
+rake tasks (Rakefile, `lib/tasks`, `rakelib`), each with its arguments,
+description and file: the first 15 at `standard`, every one at `full`.
+Then the app's own generators under `lib/generators` (the `bin/rails generate`
+command and its USAGE line), the `lib/templates` files that replace a built-in
+generator's template, and the Railties under `lib/` with their initializers.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -179,8 +184,17 @@ Concerns as `[UNAVAILABLE]` rather than dropped.
 Callbacks grouped by type, in Rails event order, with source code. The list
 covers concern-declared callbacks too, with the body read from the concern
 file, and the "From Concerns" section says which concern declared each one.
-Within one type the order is declaration order (the model file first, then
-its concerns), not the order Rails registered them in.
+Within one type the order is the order Rails runs them: base classes first, a
+concern's callbacks where its `include` line stands, then the model's own, and
+a `before_` or `around_` callback with `prepend: true` first. `after_commit`
+and `after_rollback` are last declared first unless the app turns on
+`run_after_transaction_callbacks_in_order_defined` (`load_defaults 7.1`). A
+method declared again for one type shows once, with the later declaration's
+conditions, as Rails keeps it. The order is read from source in both tiers,
+and dynamic dispatch is not evaluated: a callback registered through
+`send(:before_save, ...)`, through a method called with `send` or defined with
+`define_singleton_method`, or through a module included in `class << self` is
+not read, so the list can miss it or show the definition it replaces.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -226,7 +240,9 @@ fully qualified controller key answers with its own routes only; a short name
 reaches the controller whose trailing segments it spells, and not the ones that
 merely start with it. Rack apps attached with `mount`
 or `match ... to:` are named with the path they answer on, when the source
-spells one out.
+spells one out. A mounted Grape API lists its endpoints under the mount (verb,
+full path, declared params), read from its classes in `app/api` and `lib/api`;
+the summary counts them.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -367,7 +383,7 @@ API layer: api_only mode, serialization strategy (Jbuilder, serializers), GraphQ
 
 ### `rails_get_conventions`
 
-Auth checks, flash messages, create action template, test patterns.
+Auth checks, flash messages, create action template, test patterns, and the admin resources ActiveAdmin, Administrate, Avo, Madmin and Trestle register (with ActiveAdmin's permitted params).
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -375,7 +391,7 @@ Auth checks, flash messages, create action template, test patterns.
 
 ### `rails_get_config`
 
-Database config, auth framework, assets, cache, queue, Action Cable.
+Database config, auth framework, assets, cache, queue, Action Cable. The `use` and `map` calls in `config.ru` are listed apart from the stack, since they run before Rails.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -393,7 +409,7 @@ found under a load-order prefix too (`config/initializers/3_omniauth.rb`).
 
 ### `rails_get_env`
 
-Environment variables + credentials keys (values are never exposed). Scans `.rb`, `.rake`, ERB views and config YAML under `app`, `config` and `lib`; files matching `sensitive_patterns` (`config/database.yml`, credentials, keys) are never read, and the answer says so. A variable whose call sites pass different defaults is labelled as such rather than with one site's default; `detail:"full"` names each site's. A default is redacted by the rule a source literal gets: a credential format under any name, a URL's password, and under a secret-named variable a value that is not clearly something else, so an address, URL or hostname default prints as written.
+Environment variables + credentials keys (values are never exposed). Scans `.rb`, `.rake`, ERB views and config YAML under `app`, `config` and `lib`, plus `config.ru`, `db/seeds.rb`, `db/seeds/` and the Ruby scripts in `bin/`; files matching `sensitive_patterns` (`config/database.yml`, credentials, keys) are never read, and the answer says so. The env Kamal's `config/deploy.yml` gives the app container is listed too: secret names only, and clear values, except one holding a URL or a key-like token, or under a secret-named variable, which shows as hidden, and one an ERB tag sets, which says so. So are the setting keys in the config gem's `config/settings.yml` and `config/settings/<env>.yml` when the bundle has the config gem, and the attributes of each `Anyway::Config` class in `config/configs` or `app/configs` with the env name it reads (`PAYMENT_API_KEY`), never their values. A variable whose call sites pass different defaults is labelled as such rather than with one site's default; `detail:"full"` names each site's. A default is redacted by the rule a source literal gets: a credential format under any name, a URL's password, and under a secret-named variable a value that is not clearly something else, so an address, URL or hostname default prints as written.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -409,7 +425,9 @@ Application and framework helpers with view cross-references.
 
 ### `rails_get_service_pattern`
 
-Service object interface, dependencies, side effects, callers. An
+Service object interface, dependencies, side effects, callers, read from
+`app/services/`, `app/interactions/` and `app/interactors/`. An interactor
+organizer lists the steps it runs, in order. An
 ActiveInteraction's inputs include the ones it inherits, with the filters
 nested inside a `hash` filter shown under it. Callers are read from every
 `app/` and `lib/` tree, and on a booted app from any other directory it
@@ -437,7 +455,18 @@ job inherits from is not counted as a job; the listing names the ones it left
 out, in the sentence the service and mailer listings use, and `job:` answers
 for one of them with what every job below it inherits: its queue, options,
 retries, mixins, throttle and callbacks, and which jobs inherit it. `job:`
-answers a worker name as well as a job name.
+answers a worker name as well as a job name. A job's own page shows its
+`queue_with_priority`, `enqueue_after_transaction_commit` and Solid Queue
+`limits_concurrency` (its own or the nearest base's), every `retry_on` option,
+Sidekiq's `sidekiq_retry_in` and `sidekiq_retries_exhausted` blocks, and its
+enqueue, perform and discard callbacks as written. A job that includes
+`ActiveJob::Continuable` (itself or through a base) is marked continuable, with
+the steps its `perform` runs in order, each a block or a method. A model method
+delayed_job's `handle_asynchronously` wraps is listed as a background method with
+its options, here and on the model's `rails_get_model_details` page. The listing names the queues
+`config/sidekiq.yml` declares and the queues Solid Queue's workers poll in
+`config/queue.yml` (this environment's section), and names each job queue no
+worker polls; that job's page says so beside its queue.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -467,6 +496,19 @@ I18n setup: default/available locales, backend, locale files with key counts, pe
 
 ActionMailer mailers: every mailer class with its delivery actions and delivery method. A mailer that declares no action of its own - one taking them from a gem base or a mixin, or one called through class methods - is listed with where its actions come from rather than left out. A base other mailers inherit from is not one: it leaves the listing, and a line above names the ones left out. Asked for by name, a base answers with what every mailer below it inherits - its layout, helpers, defaults, callbacks and mixins as the app wrote them, the methods it defines - and which mailers inherit it.
 
+Each mailer also shows its own `default`, `layout`, `helper` and action and
+deliver callbacks as written, the template formats of each action under
+`app/views/<mailer>`, and its preview class with the emails it previews (read
+from `test/mailers/previews`, `spec/mailers/previews` and the
+`action_mailer.preview_paths` the config adds). The full listing opens with the
+queue `deliver_later` uses (ActionMailer's setting booted; the config's
+statically, ActiveJob's default queue from `load_defaults` 6.1 on), the
+interceptors and observers the config registers, and the preview paths.
+
+The full listing ends with the Action Mailbox mailboxes: the `routing` rules in
+the order Rails tries them, the mailbox each sends to (and whether `app/mailboxes`
+defines it), and each mailbox's processing callbacks.
+
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
 | `mailer` | string | - | One mailer, by exact name |
@@ -487,13 +529,17 @@ Autoloading setup: Zeitwerk vs Classic mode, autoloaders with collapsed/ignored
 
 ### `rails_get_active_support`
 
-ActiveSupport surface: concerns registry, deprecators, MessageVerifier/MessageEncryptor usage, tagged logging, subscribed `on_load` hooks, cache store. Validator classes living among the concerns are counted and listed apart from them, as `rails_get_concern` does.
+ActiveSupport surface: concerns registry, deprecators, MessageVerifier/MessageEncryptor usage, the `ActiveSupport::Notifications` events the app subscribes to (`subscribe`, `monotonic_subscribe`, and a Subscriber's `attach_to`) with file and line, read from source in both tiers, tagged logging, subscribed `on_load` hooks, cache store. Validator classes living among the concerns are counted and listed apart from them, as `rails_get_concern` does.
 
 *No parameters.*
 
 ### `rails_get_env_config`
 
-Per-environment configuration from `config/environments/*.rb`: notable toggles (`force_ssl`, `eager_load`, caching, log level, queue adapter, mailer delivery) and every config key each environment sets. A key assigned in more than one branch reports every value with its condition; booted, the running environment reports the value the app resolved.
+Per-environment configuration from `config/environments/*.rb`: notable toggles (`force_ssl`, `eager_load`, caching, log level, queue adapter, mailer delivery) and every config key each environment sets. A key assigned in more than one branch reports every value with its condition; booted, the running environment reports the value the app resolved. An
+"Every environment" block above them lists the keys `config/application.rb`
+sets (`config.x` included) and, for each `config_for(:name)`, the keys
+`config/name.yml` gives the running environment, `shared` merged in, names
+only.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|

data/lib/generators/rails_ai_context/install/install_generator.rb

@@ -229,6 +229,7 @@ module RailsAiContext
         "Frontend" => <<~SECTION
             # ── Frontend Framework Detection ─────────────────────────────────
             # Auto-detected from package.json, config/vite.json, etc. Override only if needed.
+            # A path outside the app root is read for package.json, lockfiles, bundler config and its tsconfig.json.
             # config.frontend_paths = ["app/frontend", "../web-client"]
         SECTION
       }.freeze

data/lib/rails_ai_context/action_filters.rb

@@ -10,11 +10,14 @@ module RailsAiContext
   # excludes what the class skipped, so the parent's filters are separated by
   # name rather than added.
   module ActionFilters
-    SKIP_MACROS = %i[skip_before_action skip_after_action skip_around_action].freeze
+    # The ancestors' filters, the names they dropped, the conditions they set, every name they
+    # declare, and whether every class up to ActionController was read.
+    ParentWalk = Struct.new(:filters, :dropped, :conditions, :declares, :whole_chain)
 
     module_function
 
-    # { own: [filter], inherited: [filter], skipped: [name] } for one action.
+    # { own: [filter], inherited: [filter], chain: [filter], skipped: [name] } for one action:
+    # `chain` is own and inherited together, in the order Rails adds them; after filters run in reverse.
     # `source:` is the controller's source when the caller already has it.
     def for(ctx, controller_name, action, source: nil, root: nil)
       split(ctx, controller_name, action.to_s, source: source, root: root)
@@ -37,15 +40,17 @@ module RailsAiContext
 
     def split(ctx, controller_name, action, source:, root:)
       info = Payload.controllers(ctx)[controller_name.to_s]
-      return { own: [], inherited: [], skipped: [] } unless info.is_a?(Hash)
+      return { own: [], inherited: [], chain: [], skipped: [] } unless info.is_a?(Hash)
 
       skips = own_skips(ctx, controller_name, info, action, root: root, source: source)
       skipped = absolute_names(skips, action)
       # A skip record states what does not run, so it is never a filter.
-      declared = Array(info[:filters]).grep(Hash).reject { |f| f[:skipped] }
-      parent, dropped, inherited_conditions, declares = parent_filters(ctx, info[:parent_class], action, skipped,
-                                                                       root: root, within: controller_name.to_s)
-      conditions = merge_conditions(inherited_conditions, conditions_by_name(skips, action))
+      offsets = Hash.new(0)
+      declared = number_blocks(Array(info[:filters]).grep(Hash).reject { |f| f[:skipped] }, offsets)
+      walk = parent_filters(ctx, info[:parent_class], action, skipped, root: root, within: controller_name.to_s, offsets: offsets)
+      parent = walk.filters
+      dropped = walk.dropped
+      conditions = merge_conditions(walk.conditions, conditions_by_name(skips, action))
       # The runtime tier's list is the whole chain, so an ancestor's skip
       # applies here too - except to what this body declares again, which
       # Rails re-adds.
@@ -73,16 +78,71 @@ module RailsAiContext
                           runs_once?(f[:from_concern], root, controller_name))
       end
       own = mark_conditional_skips(applicable.reject(&inherited_here), conditions, action)
-      inherited = mark_conditional_skips(
-        parent.reject { |f| declared_names.include?(entry_key(f)) } +
-          applicable.select(&inherited_here)
-            .map { |f| f.except(:from, :from_concern, :provenance).merge(attribution_of[entry_key(f)]) }, conditions, action
-      )
+      # The runtime tier's list is the whole chain: once the body, every ancestor and every module
+      # they mix in were read, a name none of them declares was installed from outside it (a gem's on_load).
+      outside = []
+      whole_chain = walk.whole_chain && info[:concerns_unread].blank?
+      if whole_chain && Array(info[:filters]).grep(Hash).any? { |f| f[:declared] || f[:skipped] }
+        outside, own = own.partition { |f| !f[:declared] && !f[:from_concern] }
+        outside = outside.map { |f| f.merge(provenance: "not declared in the controller chain") }
+      end
+      moved = applicable.select(&inherited_here)
+        .map { |f| f.except(:from, :from_concern, :provenance).merge(attribution_of[entry_key(f)]) }
+        .group_by { |f| entry_key(f) }
+      # Each moved entry takes its ancestor's slot, so one the runtime list does not carry keeps its place among them.
+      kept = parent.flat_map { |f| declared_names.include?(entry_key(f)) ? Array(moved.delete(entry_key(f))) : [ f ] }
+      inherited = mark_conditional_skips(kept + moved.values.flatten, conditions, action) + outside
+      own = unnumbered(own)
+      inherited = unnumbered(inherited)
+      inherited += unplaced_conditional_skips(own + inherited, conditions, action,
+                                              walk.declares | declared.map { |f| f[:name].to_s }.to_set)
+      chain = run_sequence(inherited + own, info)
+      mine = own.to_set.compare_by_identity
+
+      { own: chain.select { |f| mine.include?(f) }, inherited: chain.reject { |f| mine.include?(f) },
+        chain: chain, skipped: skipped }
+    end
+
+    # The runtime tier's list is the reflection list, already in run order; a filter it
+    # does not carry keeps its declared place, just after the carried filter declared before it.
+    # The static tier's lists are declarations, which Rails appends in turn and a prepend_* macro unshifts.
+    def run_sequence(filters, info)
+      declared = filters.each_with_object([]) { |f, list| f[:prepend] ? list.unshift(f) : list.push(f) }
+      return declared if RailsAiContext.static_tier?
+
+      rank = {}
+      Array(info[:filters]).grep(Hash).reject { |f| f[:skipped] }.each_with_index { |f, i| rank[entry_key(f)] ||= i }
+      leading = []
+      behind = {}.compare_by_identity
+      last = nil
+      declared.each do |f|
+        next (last ? behind[last] : leading) << f unless rank.key?(entry_key(f))
+
+        behind[f] = []
+        last = f
+      end
+      leading + behind.keys.each_with_index.sort_by { |f, i| [ rank[entry_key(f)], i ] }.flat_map { |f, _| [ f ] + behind[f] }
+    end
+
+    BLOCK_NUMBER = /#\d+\z/
+
+    # Numbered from the chain's end so one block reads the same in a class's list and every descendant's.
+    def number_blocks(filters, offsets)
+      seen = Hash.new(0)
+      numbered = filters.reverse.map do |filter|
+        next filter unless Introspectors::ControllerFilters.block?(filter[:name])
+
+        key = entry_key(filter)
+        number = offsets[key] + seen[key]
+        seen[key] += 1
+        filter.merge(name: "#{filter[:name]}##{number}")
+      end.reverse
+      filters.each { |filter| offsets[entry_key(filter)] += 1 if filter[:declared] && Introspectors::ControllerFilters.block?(filter[:name]) }
+      numbered
+    end
 
-      { own: own,
-        inherited: inherited + unplaced_conditional_skips(own + inherited, conditions, action,
-                                                          declares | declared.map { |f| f[:name].to_s }.to_set),
-        skipped: skipped }
+    def unnumbered(filters)
+      filters.map { |filter| filter[:name].to_s.match?(BLOCK_NUMBER) ? filter.merge(name: filter[:name].to_s.sub(BLOCK_NUMBER, "")) : filter }
     end
 
     # A skip of a name no ancestor in the payload declares is the only
@@ -98,7 +158,7 @@ module RailsAiContext
     # A conditional skip never removes the filter; the record carries the
     # condition. See CONTEXT.md, "Filter chain".
     def conditional?(skip, action)
-      !skip[:if].nil? || !skip[:unless].nil? || partial?(skip, action)
+      !skip[:if].nil? || !skip[:unless].nil? || !skip[:condition].nil? || partial?(skip, action)
     end
 
     # Partial only where the answer covers every action: a per-action answer
@@ -139,6 +199,7 @@ module RailsAiContext
 
       tail[:skipped_if] = condition_text(skip[:if]) if skip[:if]
       tail[:skipped_unless] = condition_text(skip[:unless]) if skip[:unless]
+      tail[:skipped_condition] = skip[:condition] if skip[:condition]
       return tail unless partial?(skip, action)
 
       tail[:skipped_on] = action_names(skip[:only]) if Array(skip[:only]).any?
@@ -181,7 +242,7 @@ module RailsAiContext
     # ends it: reconstructing a path from a class name breaks on every app
     # inflection. A bare superclass is resolved against the enclosing namespace
     # first, the way Ruby does.
-    def parent_filters(ctx, parent_class, action, skipped, root:, within: nil)
+    def parent_filters(ctx, parent_class, action, skipped, root:, within: nil, offsets: Hash.new(0))
       controllers = Payload.controllers(ctx)
       seen = Set.new
       found = {}
@@ -194,18 +255,30 @@ module RailsAiContext
       evidence = {}
       depth = 0
       dropped = skipped.map(&:to_s).to_set
+      # Whole only when every class up to ActionController was read: a walk that
+      # stops early may have missed the class that declares a name.
+      whole = true
+      reached = false
       name = Introspectors::ActionResolver.resolve_entry_name(controllers, parent_class, within)
 
       while name && !seen.include?(name)
         seen << name
         depth += 1
         info = controllers[name]
-        source = info.is_a?(Hash) ? nil : base_controller_source(name, root)
-        info ||= { filters: base_filters(source, name, root) } if source
+        path = info.is_a?(Hash) ? nil : base_controller_path(name, root)
+        source = path && SafeFile.read(path)
+        if source
+          info ||= { filters: base_filters(source, name, root), file: PortablePath.relativize(path, (root || default_root).to_s),
+                     parent_class: Introspectors::DeclaredConstant.parent_declaration(source, name.to_s)&.superclass }
+        end
         unless info.is_a?(Hash)
+          framework = name.to_s.delete_prefix("::").start_with?("ActionController::")
+          reached ||= framework
+          whole &&= framework
           name = gem_controller_base(name, root)
           next
         end
+        whole = false if info[:error]
 
         # The class that skips a filter must not contribute it either: in the
         # booted tier its own list is the reflection list, which carries every
@@ -215,7 +288,9 @@ module RailsAiContext
         # The walk runs closest ancestor first, so a nearer class's condition
         # is the one the child inherits.
         conditions = merge_conditions(conditions_by_name(skips, action), conditions)
-        carried = Array(info[:filters]).grep(Hash).reject { |f| f[:skipped] }
+        # The child's chain names this class's own blocks by the file they are in.
+        carried = number_blocks(Introspectors::ControllerFilters.in_file(Array(info[:filters]).grep(Hash).reject { |f| f[:skipped] }, info[:file]),
+                                offsets)
         # Counted before the rejects below, so a conditional skip of a name
         # the walk did see is never mistaken for a skip of a declaration it
         # could not. A skip record is not a sighting, hence the reject above.
@@ -233,7 +308,7 @@ module RailsAiContext
         name = Introspectors::ActionResolver.resolve_entry_name(controllers, info[:parent_class], name)
       end
 
-      [ run_order(found, attributed, positions, evidence), dropped, conditions, declares ]
+      ParentWalk.new(run_order(found, attributed, positions, evidence), dropped, conditions, declares, whole && reached)
     end
 
     # The closest ancestor carrying a filter keeps its constraints, but a
@@ -266,7 +341,7 @@ module RailsAiContext
         .sort_by { |key, index| [ -positions.fetch(key, 0), index ] }
         .map do |key, _|
           entry = found[key]
-          next entry if attributed.include?(key) || !evidence[key]
+          next entry if attributed.include?(key) || !evidence[key] || entry[:from_concern]
 
           entry.merge(from: nil, provenance: "not declared in the controller chain").compact
         end
@@ -313,7 +388,8 @@ module RailsAiContext
     def skip_flag_records(info, action)
       last_records(info, action).select { |_, f| f[:skipped] }
         .map do |name, f|
-          { name: name, kind: f[:kind], if: f[:if], unless: f[:unless], only: f[:only], except: f[:except] }
+          { name: name, kind: f[:kind], if: f[:if], unless: f[:unless], only: f[:only], except: f[:except],
+            condition: f[:condition] }
         end
     end
 
@@ -344,17 +420,9 @@ module RailsAiContext
       source ||= carried_source(ctx, controller_name, root)
       return [] unless source
 
-      skip_calls(source).flat_map do |call|
-        options = call[:options] || {}
-        next [] unless applies?({ only: options[:only], except: options[:except] }, action)
-
-        kind = call[:name].to_s.sub(/\Askip_/, "").sub(/_action\z/, "")
-        Array(call[:arguments]).select { |a| a.is_a?(Symbol) || a.is_a?(String) }
-          .map do |a|
-            { name: a.to_s, kind: kind, if: options[:if], unless: options[:unless],
-              only: options[:only], except: options[:except] }
-          end
-      end.uniq { |skip| skip[:name] }
+      skip_records(source).select { |skip| applies?(skip, action) }
+        .map { |skip| skip.slice(:name, :kind, :if, :unless, :only, :except, :condition) }
+        .uniq { |skip| skip[:name] }
     rescue => e
       RailsAiContext.debug_fail(e, [], label: "ActionFilters skip_source_records")
     end
@@ -365,13 +433,16 @@ module RailsAiContext
     # printed it. Only a name the app has a file for is read,
     # so a gem-owned parent, or one an inflection renames, still ends the walk.
     def base_controller_source(name, root)
+      path = base_controller_path(name, root)
+      path && SafeFile.read(path)
+    end
+
+    def base_controller_path(name, root)
       root ||= default_root
       return nil unless root
 
       relative = "#{name.to_s.underscore}.rb"
-      path = PathResolver.controller_dirs(root.to_s).map { |dir| File.join(dir, relative) }
-                         .find { |candidate| File.exist?(candidate) }
-      path && SafeFile.read(path)
+      PathResolver.controller_dirs(root.to_s).map { |dir| File.join(dir, relative) }.find { |candidate| File.exist?(candidate) }
     end
 
     # Gem controllers whose base class is set in the app's initializers:
@@ -401,11 +472,10 @@ module RailsAiContext
     # A module whose file is not found is taken for a concern.
     def runs_once?(name, root, within)
       root ||= default_root
-      path = root && ConcernPaths.find_file(root.to_s, name, prefer: "controller", within: within.to_s)
-      source = path && SafeFile.read(path)
+      source = root && ConcernPaths.module_source(root.to_s, name, prefer: "controller", within: within.to_s)
       return true unless source
 
-      RunCache.fetch([ :concern_module, path ]) do
+      RunCache.fetch([ :concern_module, source ]) do
         Introspectors::SourceIntrospector.walk_source(source, { mixins: Introspectors::Listeners::MixinsListener })[:mixins]
           .any? { |mixin| mixin[:macro] == :extend && mixin[:name] == "ActiveSupport::Concern" }
       end
@@ -413,7 +483,7 @@ module RailsAiContext
 
     # The last value the initializers set; :computed when it is not a string literal.
     def configured_base(root, setting)
-      Dir.glob(File.join(root.to_s, "config", "initializers", "**", "*.rb")).sort.filter_map do |path|
+      PathResolver.initializer_paths(root).filter_map do |path|
         source = SafeFile.read(path)
         next unless source&.include?(setting.delete_suffix("="))
 
@@ -443,18 +513,21 @@ module RailsAiContext
       SafeFile.read(File.join(root.to_s, file))
     end
 
-    def skip_calls(source)
-      Introspectors::SourceIntrospector.walk_source(source, {
-        skips: -> { Introspectors::Listeners::MethodCallListener.new(names: SKIP_MACROS) }
-      })[:skips] || []
+    # The reader the listing uses, so a skip carries the same only:/except:/if:/unless: and the
+    # if/unless around it; one inside a `def` runs only when called, which ControllerFilters reads.
+    def skip_records(source)
+      RunCache.fetch([ :skip_records, source ]) do
+        Introspectors::ControllerFilters.from_source(source).select { |f| f[:skipped] }
+      end
     end
 
     private_class_method :default_root, :split, :applies?, :parent_filters, :skip_source_records, :carried_source,
                          :entry_key,
 
-                         :skip_calls, :base_filters, :skip_flag_records, :redeclared_names, :last_records, :own_skips,
+                         :skip_records, :base_filters, :skip_flag_records, :redeclared_names, :last_records, :own_skips,
                          :record_attribution, :conditional?, :partial?, :absolute_names, :conditions_by_name,
                          :merge_conditions, :mark_conditional_skips, :skip_tail, :action_names, :condition_text,
-                         :unplaced_conditional_skips, :evidence_skips, :gem_controller_base, :configured_base, :runs_once?
+                         :unplaced_conditional_skips, :evidence_skips, :configured_base, :runs_once?, :run_sequence,
+                         :base_controller_path, :number_blocks, :unnumbered
   end
 end

data/lib/rails_ai_context/app_commands.rb

@@ -13,14 +13,14 @@ module RailsAiContext
       "bin/rails server" if File.exist?(File.join(root.to_s, "bin", "rails"))
     end
 
-    # Builds the database from the schema the app keeps, else its migrations.
+    # Builds the database from the dump the app keeps, under whatever name schema_dump gives it, else its migrations.
     # db:setup is not named: it also runs the seeds.
     #
     # @return [String, nil] nil for an app with no database config or bin/rails
     def setup(root)
       root = root.to_s
       return nil unless File.exist?(File.join(root, "bin", "rails")) && File.exist?(File.join(root, "config", "database.yml"))
-      return "bin/rails db:create db:schema:load" if %w[schema.rb structure.sql].any? { |f| File.exist?(File.join(root, "db", f)) }
+      return "bin/rails db:create db:schema:load" if Introspectors::SchemaDumpPath.present(root)
       return "bin/rails db:create db:migrate" if Dir.exist?(File.join(root, "db", "migrate"))
 
       "bin/rails db:create"

data/lib/rails_ai_context/app_kind.rb

@@ -7,16 +7,73 @@ module RailsAiContext
     module_function
 
     def mongoid?(root)
-      root = root.to_s
-      return true if File.exist?(File.join(root, "config", "mongoid.yml"))
+      File.exist?(File.join(root.to_s, "config", "mongoid.yml")) || uses_gem?(root, "mongoid")
+    end
+
+    def sequel?(root)
+      uses_gem?(root, "sequel-rails", "sequel")
+    end
+
+    def uses_gem?(root, *names)
+      lock = RailsAiContext::GemLock.for(root.to_s)
+      return names.any? { |name| lock.present?(name) } unless lock.missing?
+
+      # No lockfile yet (fresh checkout, bare directory): the Gemfile's own declaration.
+      RailsAiContext::Introspectors::GemfileGems.names(root.to_s).intersect?(names)
+    end
+
+    ACTIVE_RECORD_REQUIRES = %w[rails/all active_record/railtie active_record].freeze
+
+    # False only when config/application.rb picks its frameworks railtie by
+    # railtie and leaves Active Record's out (a require, or a list it requires
+    # in a loop) and never configures it; a file it cannot read is taken to load it.
+    def active_record?(root)
+      source = RailsAiContext::SafeFile.read(File.join(root.to_s, "config", "application.rb"))
+      tree = source && RailsAiContext::AstCache.parse_string(source)
+      return true unless tree && tree.errors.empty?
+
+      nodes = Introspectors::AstWalk.each(tree.value).to_a
+      strings = nodes.grep(Prism::StringNode).map(&:unescaped)
+      return true if strings.intersect?(ACTIVE_RECORD_REQUIRES) || nodes.grep(Prism::CallNode).any? { |n| n.name == :active_record }
+
+      strings.none? { |s| s.end_with?("/railtie", "/engine") }
+    rescue StandardError, ScriptError
+      true
+    end
+
+    # Why Active Record introspection does not apply here, or nil when it does.
+    def without_active_record(root)
+      return nil if active_record?(root)
+
+      return "this app uses Mongoid" if mongoid?(root)
+      return "this app uses Sequel" if sequel?(root)
+
+      "this app does not load Active Record"
+    end
+
+    # Why the schema files Active Record would read are not its own: sequel-rails keeps its
+    # schema.rb and migrations in the same places, written in Sequel's DSL. Nil when they are.
+    def sequel_schema(root)
+      return nil unless sequel?(root)
+
+      format, dump = Introspectors::SchemaDumpPath.present(root)
+      return nil if format == :sql
+
+      file = dump || Introspectors::MigrationReplay.migration_files(Introspectors::MigrationReplay.migration_dirs(root), root: root).first
+      return nil unless file && sequel_migration?(RailsAiContext::SafeFile.read(file))
+
+      "#{file.delete_prefix("#{root.to_s.chomp('/')}/")} is a Sequel migration"
+    end
 
-      lock = RailsAiContext::GemLock.for(root)
-      return lock.present?("mongoid") unless lock.missing?
+    def sequel_migration?(source)
+      tree = source && RailsAiContext::AstCache.parse_string(source)
+      return false unless tree&.value
 
-      # No lockfile yet (fresh checkout, bare directory): fall back to the
-      # Gemfile's own declaration so the app still gets Mongoid treatment
-      # instead of misleading ActiveRecord answers.
-      RailsAiContext::Introspectors::GemfileGems.names(root).include?("mongoid")
+      tree.value.statements.body.any? do |node|
+        node.is_a?(Prism::CallNode) && node.name == :migration &&
+          (node.receiver.is_a?(Prism::ConstantReadNode) || node.receiver.is_a?(Prism::ConstantPathNode)) &&
+          node.receiver.slice.delete_prefix("::") == "Sequel"
+      end
     end
 
     # The development database config/mongoid.yml names, by `database:` or the