rails-ai-context 5.20.0 → 5.20.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e92439f72b8f723d75c6b62ca2fe3734f29b60548e50d2ddea836c93a66d952
-  data.tar.gz: c541d140c1f7971fa0f62d5e664673a338ffc7e809b8df8578035890224567d0
+  metadata.gz: 81eedfa398603e64a27f7555b4288e39a11e41093c3a06450354c2f5cb1d17c5
+  data.tar.gz: 34972bf4259e8e12695f008744111bff94ed7caa93155bd3f8352010e3134c15
 SHA512:
-  metadata.gz: e2e550d201dd7af30d4e95e5ec368d2f376d2b8812d5254ffcf10ab8f78b1f0e089df5ba5f2664fbe858dbf2a5277c15e2489df0e86b61b22ebd44868560854f
-  data.tar.gz: 80daba010490cd5b6d1e0c4e770582b4bda8db4d073ebb9bead8d2eb3f015ec966c1ce1fef60f229755e1f1610b48b2287da480d790f20ed3be705d8b4ee95d7
+  metadata.gz: c88339dc6c73a5fdb38209d69e61437a6494382c069ae943478e51a265e57b2b847d4cb89f22ef0449c024bdb43185feef7e58a5e92f199c0a0389f4822898ca
+  data.tar.gz: 2f0a283b5691f00d4f49aeed839da56af13e248f566c9a526e3926cbc0c71185cf2e99a9b809d5e316d7e1144826456bb65ea36148493b4102f44b3bf0857584

data/CHANGELOG.md

@@ -5,6 +5,104 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.20.2] - 2026-08-11
+
+### Fixed
+
+- **A long-lived process no longer answers about the app as it was at boot.**
+  The MCP server and `watch` invalidated their own caches on a file change but
+  never reloaded Rails, and `Zeitwerk#eager_load_dir` does not re-scan a
+  directory it has already loaded - so a model written after the server started
+  stayed invisible for the life of the process, and the server told callers it
+  did not exist. Routes were unaffected because `RouteIntrospector` already
+  asked `routes_reloader.execute_if_updated`. Both change handlers now run
+  Rails' own reloader first, gated on `config.enable_reloading` (the flag that
+  decides whether Rails unloads anything - `eager_load` does not), and every
+  tool call and every resource read now runs inside the executor so a reload
+  cannot unload constants while one is reading them. A failing reload leaves
+  the process alive, and a tool failure is not reported to the host app's
+  error reporter - it is handled here and returned as an isError result.
+
+- **A `validates_with` validator no longer replaces the whole model answer.**
+  `ActiveModel::Validator` has no `#attributes` - only `EachValidator` does -
+  so one of them anywhere on a model turned `rails_get_model_details`,
+  `rails_get_callbacks` and `rails://models/X` into a single
+  "Error inspecting X" line. (#121)
+- **Static-tier callbacks are reported.** The two tiers handed back different
+  types for one key: a Hash keyed by callback type when booted, a flat Array
+  from the listener otherwise. Every consumer filters on `is_a?(Hash)`, so
+  `--no-boot` answered "No models with callbacks found" for an app full of
+  them, and `--model X --no-boot` raised `TypeError` on a Hash lookup against
+  an Array. (#122)
+- **`get_mailers` reports the actions Rails calls actions.** It listed
+  `instance_methods(false)`, which includes ActiveSupport's generated
+  `_run_*_callbacks` and any public helper, so an abstract `ApplicationMailer`
+  was reported as having deliverable actions. It now asks
+  `action_methods`. (#126)
+- **One answer to which database the app runs on.** Four surfaces each carried
+  their own substitute for the internal `static_parse` marker and disagreed:
+  the generated `CLAUDE.md`, `rails_get_schema`, `rails_onboard` and
+  `rails ai:inspect` could name three different databases for one app, and
+  `onboard`'s gem loop let the last match win where the serializer's let the
+  first. They now share `RailsAiContext::SchemaAdapter`, which resolves from
+  the app's own database configuration first, then the `structure.sql` dialect
+  already parsed, then the Gemfile - order-independent. (#125)
+- **Generated context files no longer print `Database: static_parse`.** That is
+  the internal marker for "read from db/schema.rb, not the connection";
+  `onboard` already substituted the live adapter and the serializers did
+  not. (#125)
+- **`get_job_pattern` says what it checked.** "This app may not use background
+  jobs" was a claim about the whole app drawn from one directory, and apps
+  keeping Sidekiq workers in `app/workers/` were told they have none. (#120)
+- **`validate`'s empty-files message advises a syntax the CLI accepts.** It
+  recommended `files:["..."]`, which the CLI reads as a literal filename. (#124)
+- **`validate --files a.rb b.rb` validates every file.** Array parameters
+  consumed only the first token, so the rest were dropped silently and the
+  summary read "1/1 files passed" for a set containing a broken file. (#124)
+
+### Added
+
+- **The static tier reads `config.api_only`.** Without a booted app the view
+  tools fell back to "no Stimulus controllers found" on an API-only app, where a
+  booted run says "Not applicable". Both were true, but only one of them stops
+  an agent adding a view layer to an app that has none by design.
+
+## [5.20.1] - 2026-08-11
+
+### Fixed
+
+- **`config.custom_tools` no longer takes the MCP server down.** Naming a
+  `BaseTool` subclass resolved its constant, which autoloaded the class and
+  enrolled it in the same registry the built-in list is read from, so it was
+  offered to the SDK twice and rejected as a duplicate name. The server exited
+  1 with an empty stdout while the CLI kept working. Tools are now merged by
+  name; two different classes claiming one name keep the built-in and warn.
+- **`--flag value` no longer inverts boolean parameters.** A boolean flag
+  consumed no value, so `--app-only false` set `app_only` to true and dropped
+  the `false` without a warning. Affected every boolean on every tool, and
+  `--param value` is the form the CLI docs teach.
+- **The static tier stops answering questions it cannot answer.** `mailers`
+  reported "no mailers found" for an app with mailers, `engines` reported no
+  engines loaded, `i18n` reported one locale while listing two locale files,
+  and the Action Cable channels, deprecators, on_load hooks, cache store and
+  credentials sections vanished with no marker. Mailers, channels and locales
+  are read from source through `static_call`; the rest report
+  `[UNAVAILABLE]`. Locale files using YAML anchors are read correctly, and an
+  `I18n.default_locale` set in an initializer is honoured.
+- **`app_only:false` lists the routes it counts.** It announced the unfiltered
+  total above a body containing only app routes, and never showed a framework
+  route. App routes are now listed first, so they cannot paginate out of sight.
+  `app_only:true` says how many routes it hid and how to see them.
+- **One app, one route count.** Generated context files counted raw routes
+  while the tools merged each resource's `PATCH`/`PUT` pair, so `CLAUDE.md` and
+  `rails_get_routes` quoted different numbers for the same app. The totals are
+  merged at the source, and the serializers read
+  `config.excluded_route_prefixes` instead of a hardcoded copy.
+- **`rails_get_gems` past the last page** no longer opens with "No notable gems
+  found" above its own "No items at offset N" note.
+- The MCP startup banner reads the list off the built server, so it cannot
+  announce a different set of tools than the server answers with.
+
 ## [5.20.0] - 2026-08-11
 
 ### Security

data/lib/rails_ai_context/app_kind.rb

@@ -27,5 +27,28 @@ module RailsAiContext
       content = RailsAiContext::SafeFile.read(gemfile)
       !!content&.match?(/^\s*gem\s+["']mongoid["']/)
     end
+
+    # An API-only app has no view layer, and saying "no Stimulus controllers
+    # found" about one invites an agent to add some. The flag is written in
+    # config/application.rb, so this answer needs no booted app.
+    #
+    # Read from the AST, not a regex: `config.api_only = true` is an
+    # assignment, which docs/INTROSPECTORS.md puts squarely in AST territory,
+    # and ConfigAssignmentListener already reports exactly this shape. A regex
+    # also has to hand-roll what the parser knows for free - comments, strings
+    # and heredocs that merely contain the text.
+    def api_only?(root)
+      path = File.join(root.to_s, "config", "application.rb")
+      return false unless File.exist?(path)
+      return false unless RailsAiContext::SafeFile.read(path)
+
+      walked = Introspectors::SourceIntrospector.walk(
+        path, { config: Introspectors::Listeners::ConfigAssignmentListener }
+      )
+      hit = Array(walked[:config]).find { |entry| entry[:path] == [ :api_only ] }
+      !hit.nil? && hit[:value] == true
+    rescue StandardError, ScriptError
+      false
+    end
   end
 end

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -15,6 +15,13 @@ module RailsAiContext
       class ToolNotFoundError < StandardError; end
       class InvalidArgumentError < StandardError; end
 
+      # The only words that read as true, and every word a boolean flag will
+      # consume as its value. Kept together so the two cannot drift: a word
+      # accepted here but missing from TRUTHY would silently mean false.
+      TRUTHY_WORDS = %w[true 1 yes].freeze
+      FALSEY_WORDS = %w[false 0 no].freeze
+      BOOLEAN_WORDS = (TRUTHY_WORDS + FALSEY_WORDS).freeze
+
       attr_reader :tool_class, :raw_args, :json_mode, :error
 
       def initialize(tool_name, raw_args, json_mode: false)
@@ -204,13 +211,51 @@ module RailsAiContext
             if arg.include?("=")
               key, value = arg.sub("--", "").split("=", 2)
               key = key.tr("-", "_").to_sym
-              result[key] = coerce_value(value, properties[key] || {})
+              prop = properties[key] || {}
+              if prop[:type] == "array"
+                # `--files=a.rb b.rb` is the same call as `--files a.rb b.rb`;
+                # honouring only one of the two spellings docs/CLI.md teaches
+                # left the other still dropping every file after the first.
+                trailing = collect_array_values(args, i + 1)
+                result[key] = Array(coerce_value(value, prop)) + trailing
+                i += 1 + values_consumed(args, i + 1)
+                next
+              end
+              result[key] = coerce_value(value, prop)
             else
               key = arg.sub("--", "").tr("-", "_").to_sym
               prop = properties[key] || {}
 
               if prop[:type] == "boolean"
-                result[key] = true
+                # `--flag false` is the form docs/CLI.md teaches for every
+                # other param, so a boolean has to honour it too. Only an
+                # explicit boolean word is consumed - anything else stays a
+                # separate argument and the flag means true.
+                nxt = args[i + 1]
+                if nxt && BOOLEAN_WORDS.include?(nxt.downcase)
+                  result[key] = coerce_value(nxt, prop)
+                  i += 2
+                else
+                  result[key] = true
+                  i += 1
+                end
+                next
+              end
+
+              if prop[:type] == "array"
+                values = collect_array_values(args, i + 1)
+                unless values.empty?
+                  result[key] = values
+                  i += 1 + values_consumed(args, i + 1)
+                  next
+                end
+              end
+
+              # A bare `--files` with nothing after it is a mistake, not a
+              # request for `files: true` - an array param holding a Boolean
+              # reaches the tool as a type it never accepts.
+              if prop[:type] == "array"
+                result[key] = []
                 i += 1
                 next
               end
@@ -241,13 +286,28 @@ module RailsAiContext
         result
       end
 
+      # Tokens belonging to an array flag: everything up to the next flag,
+      # stopping at a rake-style `key=value` token so `--include a model=Post`
+      # does not swallow the second parameter. Each token is still
+      # comma-split, so the documented `a.rb,b.rb` form keeps working and
+      # mixing the two spellings does not fabricate a path.
+      def collect_array_values(args, from)
+        args[from..].to_a
+            .take_while { |a| !a.start_with?("--") && !a.include?("=") }
+            .flat_map { |a| Array(coerce_value(a, { type: "array" })) }
+      end
+
+      def values_consumed(args, from)
+        args[from..].to_a.take_while { |a| !a.start_with?("--") && !a.include?("=") }.size
+      end
+
       # Coerce a string value to the type specified in the JSON Schema property.
       def coerce_value(raw, property_schema)
         case property_schema[:type]
         when "integer"
           raw.to_i
         when "boolean"
-          %w[true 1 yes].include?(raw.to_s.downcase)
+          TRUTHY_WORDS.include?(raw.to_s.downcase)
         when "array"
           raw.is_a?(Array) ? raw : raw.to_s.split(",").map(&:strip)
         else

data/lib/rails_ai_context/code_reloader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Re-runs Rails' own code reloader so a long-lived process sees files written
+  # after it booted.
+  #
+  # Clearing the gem's caches is not enough on its own. Introspectors reach the
+  # app through constants, and the eager loading they trigger
+  # (`Zeitwerk::Loader#eager_load_dir`) is idempotent per process - a directory
+  # already loaded is never re-scanned, so a model added after boot stays
+  # invisible for the life of the server. Routes never had the problem because
+  # RouteIntrospector asks `routes_reloader.execute_if_updated` every call.
+  module CodeReloader
+    module_function
+
+    # Reload the app's autoloaded code. Returns whether a reload actually ran,
+    # so callers can say what they did instead of guessing.
+    def reload!
+      return false unless reloadable?
+
+      Rails.application.reloader.reload!
+      true
+    rescue StandardError, ScriptError => e
+      # A broken file mid-edit is the common case. Zeitwerk reloads by
+      # unload-then-setup, so a raise can leave constants already unloaded -
+      # they re-autoload lazily on next reference. Either way a running server
+      # must survive it.
+      $stderr.puts "[rails-ai-context] code reload failed: #{e.class}: #{e.message}" if ENV["DEBUG"]
+      false
+    end
+
+    # Run a block with the sharing lock held, so a reload cannot unload
+    # constants underneath it.
+    #
+    # `Reloader#class_unload!` takes the unload lock through
+    # ActiveSupport::Dependencies.interlock, but that only blocks threads
+    # holding the sharing lock - which is acquired inside `executor.wrap`.
+    # Nothing here wrapped anything, so the Listen thread could clear
+    # DescendantsTracker while a tool call was midway through reading
+    # `ActiveRecord::Base.descendants`, returning a short list with no
+    # exception for the per-section rescue to notice.
+    #
+    # Only taken when a reload could actually happen; everywhere else this is
+    # a plain yield.
+    def with_app_code
+      return yield unless reloadable?
+
+      app = Rails.application
+      return yield unless app.respond_to?(:executor)
+
+      app.executor.wrap { yield }
+    end
+
+    # `enable_reloading` is the flag that decides whether Rails unloads
+    # anything: with it off, the finisher registers no class_unload callback,
+    # so `reload!` runs the prepare callbacks and returns having reloaded
+    # nothing. Gating on `eager_load` instead reported success for every
+    # eager_load=false + cache_classes=true environment (stock `test`, a
+    # cache-classes staging container) - a reload that never happened,
+    # announced as one.
+    def reloadable?
+      return false if RailsAiContext.static_tier?
+      return false unless defined?(Rails) && Rails.respond_to?(:application)
+
+      app = Rails.application
+      return false unless app.respond_to?(:reloader) && app.respond_to?(:config)
+
+      config = app.config
+      # Rails 7.1+ names it enable_reloading; older releases only have
+      # cache_classes, which is its inverse.
+      return config.enable_reloading if config.respond_to?(:enable_reloading)
+      return !config.cache_classes if config.respond_to?(:cache_classes)
+
+      false
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/rails_ai_context/introspector.rb

@@ -122,9 +122,7 @@ module RailsAiContext
     end
 
     def unavailable_reason
-      reason = RailsAiContext.static_reason
-      base = "requires a booted Rails app"
-      reason ? "#{base} (#{reason})" : base
+      Introspectors::StaticTier.unavailable_reason
     end
 
     def rails_version

data/lib/rails_ai_context/introspectors/active_support_introspector.rb

@@ -8,7 +8,7 @@ module RailsAiContext
     # Covers RAILS_NERVOUS_SYSTEM.md §17 (ActiveSupport).
     class ActiveSupportIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -30,6 +30,25 @@ module RailsAiContext
         { error: e.message }
       end
 
+      # Concerns, MessageVerifier usage and tagged logging are read off disk.
+      # The registered deprecators, the subscribed load hooks and the cache
+      # store only exist in a running process; an empty list for them renders
+      # as "this app has none", so they refuse instead.
+      def static_call
+        unavailable = { unavailable: StaticTier.unavailable_reason }
+        {
+          concerns: extract_concerns,
+          deprecators: unavailable,
+          message_verifier_usage: extract_message_verifier_usage,
+          tagged_logging: detect_tagged_logging,
+          on_load_hooks: unavailable,
+          cache_usage: unavailable
+        }
+      rescue => e
+        $stderr.puts "[rails-ai-context] ActiveSupportIntrospector#static_call failed: #{e.message}" if ENV["DEBUG"]
+        { error: e.message }
+      end
+
       private
 
       def root

data/lib/rails_ai_context/introspectors/api_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # versioning patterns, rate limiting.
     class ApiIntrospector
       extend StaticTier
-      static_tier :runtime_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -14,6 +14,20 @@ module RailsAiContext
         @app = app
       end
 
+      # Everything but api_only needs a booted app, but api_only itself is a
+      # plain assignment in config/application.rb - and the view tools already
+      # read it there. Leaving this section wholly unavailable meant one
+      # process answering "this is an API-only app" from get_stimulus and
+      # "cannot say" from get_api.
+      def static_call
+        {
+          api_only: AppKind.api_only?(app.root),
+          unavailable_sections: StaticTier.unavailable_reason
+        }
+      rescue StandardError
+        { unavailable: StaticTier.unavailable_reason }
+      end
+
       def call
         {
           api_only: app.config.api_only,

data/lib/rails_ai_context/introspectors/engine_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # Identifies well-known engines and provides context about what each does.
     class EngineIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -50,6 +50,20 @@ module RailsAiContext
         { error: e.message }
       end
 
+      # config/routes.rb is a file, so mounts read the same either way. Which
+      # engine classes a process loaded is only knowable from that process -
+      # and testing `defined?(Rails::Engine)` instead of the tier answered from
+      # the half-finished boot that put us here, which is the common way into
+      # the static tier.
+      def static_call
+        {
+          mounted_engines: discover_mounted_engines,
+          rails_engines: { unavailable: StaticTier.unavailable_reason }
+        }
+      rescue => e
+        { error: e.message }
+      end
+
       private
 
       def root

data/lib/rails_ai_context/introspectors/i18n_introspector.rb

@@ -7,7 +7,12 @@ module RailsAiContext
     # Discovers internationalization setup: locales, backends, key counts.
     class I18nIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
+
+      # Both spellings apps use: `config.i18n.default_locale = :es` in
+      # application.rb or an environment file, and a bare
+      # `I18n.default_locale = :es` in an initializer.
+      DEFAULT_LOCALE_ASSIGNMENT = /(?:config\.i18n|I18n)\.default_locale\s*=\s*[:"']([\w-]+)/
 
       attr_reader :app
 
@@ -30,8 +35,65 @@ module RailsAiContext
         { error: e.message }
       end
 
+      # The locale files are the same files either way; only the list of
+      # locales and the default came from a running I18n. Read both from disk
+      # rather than report the library's own defaults as the app's.
+      def static_call
+        locales = locales_from_files
+        default = default_locale_from_config
+
+        {
+          default_locale: default,
+          available_locales: locales,
+          backend: nil,
+          locale_files: extract_locale_files,
+          total_locale_files: count_locale_files,
+          locale_coverage: detect_locale_coverage(locales: locales.map(&:to_sym), default: default.to_sym)
+        }.merge(detect_fallback_config)
+      rescue => e
+        { error: e.message }
+      end
+
       private
 
+      # Every top-level key across config/locales - the same population Rails
+      # builds available_locales from.
+      def locales_from_files
+        dir = File.join(root, "config/locales")
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**/*.{yml,yaml}")).flat_map do |path|
+          content = RailsAiContext::SafeFile.read(path)
+          next [] unless content
+
+          # aliases: true, like extract_locale_files. Sharing formats through a
+          # YAML anchor is ordinary, and without the flag Psych raises, the
+          # rescue swallows it, and every locale in that file disappears while
+          # the Locale Files section still lists it.
+          data = YAML.safe_load(content, permitted_classes: [ Symbol ], aliases: true)
+          data.is_a?(Hash) ? data.keys.map(&:to_s) : []
+        rescue StandardError
+          []
+        end.uniq.sort
+      end
+
+      # Rails' own default is :en, so "en" is the right answer when the app
+      # never says otherwise - not a guess.
+      def default_locale_from_config
+        candidates = [ File.join(root, "config", "application.rb") ] +
+                     Dir.glob(File.join(root, "config", "environments", "*.rb")) +
+                     Dir.glob(File.join(root, "config", "initializers", "*.rb"))
+
+        candidates.each do |path|
+          next unless File.exist?(path)
+
+          content = RailsAiContext::SafeFile.read(path)
+          match = content&.match(DEFAULT_LOCALE_ASSIGNMENT)
+          return match[1] if match
+        end
+        "en"
+      end
+
       def root
         app.root.to_s
       end
@@ -77,8 +139,7 @@ module RailsAiContext
         {}
       end
 
-      def detect_locale_coverage
-        locales = I18n.available_locales
+      def detect_locale_coverage(locales: I18n.available_locales, default: I18n.default_locale)
         return {} if locales.size < 2
 
         # Coverage is the share of the default locale's keys that the other
@@ -86,8 +147,8 @@ module RailsAiContext
         # for a locale that translates few default keys but adds many of its
         # own - the one number a translator must not be told is fine.
         coverage = {}
-        default_keys = key_paths_for_locale(I18n.default_locale)
-        locales.reject { |l| l == I18n.default_locale }.each do |locale|
+        default_keys = key_paths_for_locale(default)
+        locales.reject { |l| l == default }.each do |locale|
           locale_keys = key_paths_for_locale(locale)
           translated = (default_keys & locale_keys).size
           coverage[locale.to_s] = {
@@ -110,7 +171,7 @@ module RailsAiContext
         find_locale_paths(locale).flat_map do |path|
           content = RailsAiContext::SafeFile.read(path)
           next [] unless content
-          data = YAML.safe_load(content, permitted_classes: [ Symbol ])
+          data = YAML.safe_load(content, permitted_classes: [ Symbol ], aliases: true)
           next [] unless data.is_a?(Hash)
 
           # A locale root may be written `en:` or `:en:` - both load, and both

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # and Action Cable channels.
     class JobIntrospector
       extend StaticTier
-      static_tier :files_only
+      static_tier :alternate_source
 
       CHANNEL_MACROS = %i[identified_by stream_from stream_for periodically].freeze
 
@@ -31,6 +31,19 @@ module RailsAiContext
         }
       end
 
+      # Mailers and channels are ordinary classes in ordinary directories, so
+      # the answer is the same with or without a booted app. Only the way in
+      # differs: descendants when Rails is up, the AST when it is not.
+      def static_call
+        {
+          jobs: extract_jobs_from_source,
+          mailers: extract_mailers_from_source,
+          channels: extract_channels_from_source,
+          recurring_jobs: extract_solid_queue_recurring,
+          sidekiq_config: extract_sidekiq_config
+        }
+      end
+
       private
 
       def extract_jobs
@@ -221,7 +234,14 @@ module RailsAiContext
         ActionMailer::Base.descendants.filter_map do |mailer|
           next if mailer.name.nil?
 
-          actions = mailer.instance_methods(false).map(&:to_s).sort
+          # Rails' own answer: it subtracts internal and inherited methods, so
+          # an abstract ApplicationMailer reports none and ActiveSupport's
+          # generated `_run_*_callbacks` never appears. `instance_methods(false)`
+          # listed both as deliverable actions. Called bare, like
+          # ControllerIntrospector does - AbstractController::Base has defined
+          # it across the whole supported range, so a fallback here would only
+          # be unreachable code holding the old bug.
+          actions = mailer.action_methods.to_a.map(&:to_s).sort
           next if actions.empty?
 
           {
@@ -235,6 +255,65 @@ module RailsAiContext
         []
       end
 
+      # A mailer's actions are its public instance methods. The booted side asks
+      # `action_methods`, which also subtracts inherited and internal ones - the
+      # AST cannot see that, so a public helper on a concrete mailer is still
+      # listed here and not there.
+      def extract_mailers_from_source
+        source_classes(File.join(app.root, "app", "mailers")).filter_map do |name, methods|
+          next if name == "ApplicationMailer"
+
+          actions = methods.select { |m| m[:scope] == :instance && m[:visibility] == :public }
+                           .map { |m| m[:name] }.sort
+          next if actions.empty?
+
+          { name: name, actions: actions, confidence: RailsAiContext::Confidence::STATIC }
+        end.sort_by { |m| m[:name] }
+      end
+
+      def extract_channels_from_source
+        # ApplicationCable holds the base Channel and Connection, neither of
+        # which is a channel of the app's own.
+        source_classes(File.join(app.root, "app", "channels")).filter_map do |name, methods|
+          next if name.start_with?("ApplicationCable::")
+
+          stream_methods = methods.select { |m| m[:scope] == :instance }
+                                  .map { |m| m[:name] }
+                                  .select { |m| m.start_with?("stream_") || m == "subscribed" }
+          { name: name, stream_methods: stream_methods, confidence: RailsAiContext::Confidence::STATIC }
+        end.sort_by { |c| c[:name] }
+      end
+
+      # Class name plus method list for every .rb under `dir`, read from the
+      # AST. Yields nothing when the directory is absent.
+      #
+      # The name comes from the path, not the AST: Zeitwerk requires the two to
+      # agree, and only the path carries the namespace. Reading `class Channel`
+      # out of `application_cable/channel.rb` yields "Channel", which matches
+      # no base-class filter and no name the booted app would report.
+      def source_classes(dir)
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**/*.rb")).sort.filter_map do |path|
+          next unless File.exist?(path) && File.size(path) > 0
+          next if File.size(path) > RailsAiContext.configuration.max_file_size
+          # Rails adds app/*/concerns as its own autoload root, so what lives
+          # there is a mixin, not a mailer or a channel - and naming it from
+          # the path would invent a `Concerns::` namespace that never exists.
+          next if path.sub("#{dir}/", "").start_with?("concerns/")
+
+          walked = SourceIntrospector.walk(path, { methods: Listeners::MethodsListener })
+          [ constant_name_for(path, dir), walked[:methods] || [] ]
+        rescue StandardError, ScriptError => e
+          $stderr.puts "[rails-ai-context] source_classes failed for #{path}: #{e.message}" if ENV["DEBUG"]
+          nil
+        end
+      end
+
+      def constant_name_for(path, dir)
+        path.sub("#{dir}/", "").sub(/\.rb\z/, "").camelize
+      end
+
       def extract_channels
         return [] unless defined?(ActionCable::Channel::Base)