rails-ai-context 5.17.0 → 5.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebb8d4e0ebed93183c0c019071ee63d097fb8c7495f551393991000aa5d06e7b
-  data.tar.gz: 2141cf0a281a173da2f0fa34927be843f93600ced5cdd67ccd6eb4aeef261ce0
+  metadata.gz: d4a8615479dc45f376da0873dbd18511feda7dafddad0e4c4c14039d26f8a4bf
+  data.tar.gz: 9fa06c53d871f05d30c284964777ebd15b26d44e87284e9232591e288ab47d29
 SHA512:
-  metadata.gz: e1bdda115ee2c82a43af9f6389ad18204629539e5867db0ae36d8c4fe86f50547084315470ed5842adccbced095026e2a220f32626d1c1e43600b595d7224afb
-  data.tar.gz: 197fe45172ce6888fd89ee63ecc505f5e014f1b3c759a918a7244025958ce9d17801f4bf1a0ac3ce401a93063b0f3d75998b4ec485f6bdbe4df9449be333920d
+  metadata.gz: 38cc97cb5ec47c4ecd680ebb588169372d4d5a41c53dd0c59fde9260dc2bffad4f9830ffea5bc84cbef0079b167d522bccf77903104e5f6e5a03bd93aa85445d
+  data.tar.gz: 9987140ad897944e8def9318c6eedad861228f345465937062dba5e6ea36a2c47246d5c0697acce041afe7966b866d40bd289e67eeb1d582a6b220cc5c6dc147

data/CHANGELOG.md

@@ -5,6 +5,48 @@ 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.18.0] - 2026-08-09
+
+### Added
+
+- **Three new Prism listeners.** `ConfigAssignmentListener` reads
+  `config.key = value` and `config.key.subkey = value` in initializers, matching
+  the root anywhere in the chain so `Rails.application.config.assets.paths`
+  resolves too. `ComponentStructureListener` reads ViewComponent and Phlex
+  structure: `renders_one`/`renders_many`, slot methods, constant tables,
+  `case @ivar` variant branching, and `CONST[@ivar]` indexing.
+  `ClassDefinitionListener` reads class definitions with their superclass.
+- **`docs/INTROSPECTORS.md` documents the listener catalogue**, how to add a
+  listener, and when regex is the right tool instead of the AST.
+
+### Changed
+
+- **Auth, component, channel, controller, inflection and initializer reading
+  moved from regex to the AST.** Devise and Doorkeeper settings, devise-jwt
+  detection, ViewComponent and Phlex structure, Action Cable `identified_by` /
+  `stream_from` / `stream_for` / `periodically`, `rate_limit` options, custom
+  inflections, CORS origins, RSpec helper `include`s, `DatabaseCleaner.strategy`
+  and model class detection are all read structurally now. Formatting that used
+  to defeat the patterns (multi-line arguments, adjacent string literals,
+  `%i[]` and `%w[]` forms) is read correctly.
+- **A filter's `if:` condition reports the action it names.** A lambda has no
+  literal value, so `if: -> { action_name == "create" }` used to surface as
+  `[INFERRED]`; it now reads `action_name == "create"`. Same key, same type.
+- **`rate_limit_parsed[:within]` no longer keeps a trailing comma.**
+  `within: 1.minute, only: :create` returned `"1.minute,"` and now returns
+  `"1.minute"`.
+- **Initializer `setup_calls` sees more.** The old pattern only matched a line
+  beginning with `config.`, so `Rails.application.config.x = y` and multi-line
+  chains were missed.
+- **Every remaining regex over Ruby source carries a note** saying why regex is
+  right there: non-Ruby files, mixed-extension globs, vocabulary matching, or
+  scope the listeners cannot see.
+
+### Fixed
+
+- **Dead namespace-tracking loop removed from `RakeTaskIntrospector`**, which
+  walked every line of every `.rake` file and discarded the result.
+
 ## [5.17.0] - 2026-08-09
 
 ### Added

data/CONTRIBUTING.md

@@ -51,11 +51,13 @@ Listeners extract specific concerns (associations, validations, etc.) from the A
 1. Create `lib/rails_ai_context/introspectors/listeners/your_listener.rb` inheriting from `BaseListener`
 2. Implement `on_call_node_enter(node)` and/or `on_def_node_enter(node)` - only the events your concern needs
 3. Use `confidence_for(node)` from `BaseListener` to tag results `[VERIFIED]` or `[INFERRED]`
-4. Store results in `@results` (accessed via `#results`)
-5. Register the key/class pair in `SourceIntrospector::LISTENER_MAP`
-6. Write specs in `spec/lib/rails_ai_context/introspectors/listeners/your_listener_spec.rb`
+4. Store results in `@results` (accessed via `#results`) as plain hashes, never Prism nodes
+5. If your listener needs an event `SourceIntrospector.register_listener` doesn't already wire up, add it there
+6. Register the key/class pair in `SourceIntrospector::LISTENER_MAP` only if the listener should run on every model walk; listeners used by one introspector are passed to `SourceIntrospector.walk(path, key => Listener)` at the call site instead
+7. Write specs in `spec/lib/rails_ai_context/introspectors/listeners/your_listener_spec.rb`
+8. Add a row to the listener catalogue in `docs/INTROSPECTORS.md`
 
-See existing listeners in `lib/rails_ai_context/introspectors/listeners/` for reference patterns.
+See existing listeners in `lib/rails_ai_context/introspectors/listeners/` for reference patterns, and `docs/INTROSPECTORS.md` for the catalogue and the AST-vs-regex rule.
 
 ## Adding a CLI Tool Interface
 

data/docs/ARCHITECTURE.md

@@ -26,7 +26,7 @@ graph TD
         subgraph engine["Introspection Engine"]
             direction LR
             I["Introspectors\n39 modules\nPresets\nCached"]
-            AST["AST Engine\nPrism\n21 listeners\nConfidence tags"]
+            AST["AST Engine\nPrism\n24 listeners\nConfidence tags"]
             H["Hydration Layer\nSchema hints\ninjected into\ntool responses"]
         end
 

data/docs/INTROSPECTORS.md

@@ -171,7 +171,7 @@ These introspectors map directly onto [`RAILS_NERVOUS_SYSTEM.md`](../RAILS_NERVO
 
 The **SourceIntrospector** uses Prism AST parsing for model analysis. It is infrastructure shared by the introspectors above rather than an introspector you can enable: there is no `:source` key for `config.introspectors`.
 
-It runs a single-pass Dispatcher that walks the AST once and feeds events to all registered listeners simultaneously. Model analysis uses the seven below by default; the other fourteen listener classes are used through targeted walks (schema dumps, migrations, Gemfiles, rake tasks, initializers, and so on), for 21 in total.
+It runs a single-pass Dispatcher that walks the AST once and feeds events to all registered listeners simultaneously. Model analysis uses the seven below by default; the rest are used through targeted walks (schema dumps, migrations, Gemfiles, rake tasks, initializers, components, and so on).
 
 ### The 7 default Prism listeners
 
@@ -185,6 +185,51 @@ It runs a single-pass Dispatcher that walks the AST once and feeds events to all
 | MacrosListener | `encrypts`, `normalizes`, `delegate`, `has_secure_password`, `serialize`, `store`, `has_one_attached`, `has_many_attached`, `has_rich_text`, `generates_token_for`, `attribute` |
 | MethodsListener | `def`/`def self.`, visibility tracking, parameter extraction, `class << self` |
 
+### The targeted-walk listeners
+
+Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file needs reading. Several take arguments, so one class serves many callers.
+
+| Listener | What it detects |
+|:---------|:---------------|
+| GenericMacroListener | Any receiver-less macro you name: `GenericMacroListener.new(:devise, :rate_limit)`. Returns args, values (with a source-slice fallback), options, option values and option nodes |
+| ChainedCallListener | Calls on a receiver: `ChainedCallListener.new(:includes)`, or `receiver: :inflect` to pin the receiver. Reports the receiver name |
+| ConfigAssignmentListener | `config.key = value` and `config.a.b = value` in initializers, plus bare `config.jwt do ... end` section references. Takes a root name (`:config` by default, e.g. `:DatabaseCleaner`) |
+| ClassDefinitionListener | Class definitions with their superclass, namespaces resolved |
+| ComponentStructureListener | ViewComponent and Phlex structure: `renders_one`/`renders_many`, slot methods, hash/array constant tables, `case @ivar` variant branching, `CONST[@ivar]` indexing |
+| MiddlewareConfigListener | `config.middleware.use` / `insert_before` / `insert_after` |
+| SchemaDslListener | `schema.rb`: `create_table`, `t.string`, `t.index`, `add_foreign_key`, `create_enum` |
+| MigrationDslListener | Migration DSL: `create_table`, `add_column`, `add_index`, `add_reference`, and friends |
+| RoutesDslListener | `config/routes.rb`, resolving namespace/scope/resources nesting into flat routes |
+| MountListener | `mount Sidekiq::Web, at: "/sidekiq"` and the hash form |
+| GemfileDslListener | `gem "name", "version"` and `group :development do ... end` |
+| RakeTaskDslListener | `namespace`, `desc`, `task` in `.rake` files |
+| EnvAccessListener | `ENV["KEY"]`, `ENV.fetch("KEY")`, `ENV.fetch("KEY", default)` |
+| MongoidFieldsListener | Mongoid `field`, embedded relations, custom collection names |
+| MailboxRoutingListener | Action Mailbox `routing` and processing callbacks |
+| ModelReferenceListener | Model constants used in controllers: `Post.find`, `params.require(:post)`, ivar writes |
+| VariantCallListener | `variant` calls (ChainedCallListener with `:variant` preset) |
+
+### Adding a listener
+
+1. Subclass `BaseListener` in `lib/rails_ai_context/introspectors/listeners/`. Use its helpers rather than re-reading nodes: `extract_symbol_args`, `extract_keyword_options`, `extract_arg_values` (source-slice fallback for expressions like `2.hours`), `extract_keyword_sources`, `extract_keyword_nodes`, `keyword_hash`, `constant_path_string`.
+2. Implement the `on_*_node_enter` hooks you need and push plain hashes onto `@results`. Never return Prism nodes as the result itself; `option_nodes` is the one deliberate exception, for callers that must inspect an expression's shape.
+3. Register the event in `SourceIntrospector.register_listener` if it is not already in the list (call, def, class, module, block, singleton class, case, constant write).
+4. Add a spec of the same name under `spec/lib/rails_ai_context/introspectors/listeners/`.
+5. Add a row to the table above.
+
+### Choosing between AST and regex
+
+Use the AST when the thing you want **is** a Ruby construct: a macro call and its arguments, a method definition, a class and its superclass, an assignment, a constant, a `case`. If you find yourself running a regex over text you already parsed, that is a parse of a parse. Fix it at the node.
+
+Regex is the right tool, and stays, for:
+
+- **Files that are not Ruby.** `Gemfile.lock`, YAML (`database.yml`, `sidekiq.yml`, fixtures), `structure.sql`, Dockerfiles, ERB, HAML, Slim, JavaScript.
+- **Mixed-extension globs.** A view scan spanning ERB and Phlex `.rb` needs one matcher, or the two halves drift apart.
+- **Vocabulary classification.** "Does this middleware body talk about auth?" is about words, not structure; no node carries it.
+- **Anything the listeners cannot scope.** Tying a call to the enclosing action or `namespace` block needs block scope the listeners do not track, so those fall back to line scanning.
+
+Every remaining regex over `.rb` content carries a one-line comment saying which of these it is. If you add one without a reason, convert it instead.
+
 ### Confidence tagging
 
 Every AST result carries a confidence tag:

data/lib/rails_ai_context/introspectors/active_storage_introspector.rb

@@ -112,6 +112,7 @@ module RailsAiContext
           next false unless Dir.exist?(dir)
           Dir.glob(File.join(dir, "**/*.{erb,haml,slim,js,ts,jsx,tsx,mjs,rb}")).any? do |f|
             next false if File.directory?(f)
+            # The glob spans ERB, JS and Ruby, so one text scan covers them all.
             (RailsAiContext::SafeFile.read(f) || "").match?(/direct.upload|DirectUpload|direct_upload/)
           end
         end

data/lib/rails_ai_context/introspectors/active_support_introspector.rb

@@ -102,6 +102,8 @@ module RailsAiContext
           # and would produce non-deterministic output on large monorepos.
           Dir.glob(File.join(dir, "**/*.rb")).sort.first(2000).each do |path|
             content = RailsAiContext::SafeFile.read(path) or next
+            # Mention of the class anywhere counts, so a text scan over 2000
+            # files beats parsing each one. Regex stays.
             next unless content.match?(/MessageEncryptor|MessageVerifier/)
             relative = path.sub("#{root}/", "")
             hits << { file: relative, encryptor: content.include?("MessageEncryptor"), verifier: content.include?("MessageVerifier") }

data/lib/rails_ai_context/introspectors/api_introspector.rb

@@ -103,17 +103,7 @@ module RailsAiContext
         origin_calls = ast_data[:origins]
         return nil if origin_calls.empty?
 
-        # Extract origin strings from macro args
-        origins = origin_calls.flat_map { |macro| macro[:args].map(&:to_s) }
-        # GenericMacroListener extracts symbol args; for string origins we need
-        # the raw content fallback
-        if origins.empty?
-          content = RailsAiContext::SafeFile.read(cors_path)
-          return nil unless content
-          origins = content.scan(/origins\s+(.+)$/).flatten.flat_map do |line|
-            line.scan(/["']([^"']+)["']/).flatten
-          end
-        end
+        origins = origin_calls.flat_map { |macro| macro[:values].flatten.map(&:to_s) }
 
         { file: "config/initializers/cors.rb", origins: origins }
       rescue => e

data/lib/rails_ai_context/introspectors/auth_introspector.rb

@@ -5,6 +5,11 @@ module RailsAiContext
     # Discovers authentication and authorization setup: Devise, Rails 8 auth,
     # Pundit, CanCanCan, CORS, CSP.
     class AuthIntrospector
+      # Settings reported as a bare word rather than as their literal value,
+      # matching how Devise's own docs name the strategies.
+      SYMBOL_DEVISE_SETTINGS = %i[lock_strategy unlock_strategy].freeze
+      DEVISE_SETTINGS = (%i[timeout_in maximum_attempts password_length] + SYMBOL_DEVISE_SETTINGS).freeze
+
       attr_reader :app
 
       def initialize(app)
@@ -192,8 +197,8 @@ module RailsAiContext
 
         devise_init = File.join(root, "config/initializers/devise.rb")
         if File.exist?(devise_init)
-          content = RailsAiContext::SafeFile.read(devise_init)
-          return { detected: true, jwt_configured: content&.match?(/config\.jwt\b/) || false }
+          jwt = config_assignments(devise_init).any? { |hit| hit[:path].first == :jwt }
+          return { detected: true, jwt_configured: jwt }
         end
 
         { detected: true }
@@ -208,13 +213,15 @@ module RailsAiContext
         doorkeeper_init = File.join(root, "config/initializers/doorkeeper.rb")
         return { detected: true } unless File.exist?(doorkeeper_init)
 
-        content = RailsAiContext::SafeFile.read(doorkeeper_init)
-        return { detected: true } unless content
+        ast = SourceIntrospector.walk(doorkeeper_init, {
+          settings: -> { Listeners::GenericMacroListener.new(:grant_flows, :access_token_expires_in) }
+        })
 
-        grant_flows = content.scan(/grant_flows\s+%w\[([^\]]+)\]/).flatten.first
-        grant_flows = grant_flows&.split&.map(&:strip)
+        grant_flows = ast[:settings].find { |h| h[:macro] == :grant_flows }
+        grant_flows = Array(grant_flows[:values].first).map(&:to_s) if grant_flows
 
-        expires_in = content.match(/access_token_expires_in\s+(\S+)/)&.send(:[], 1)
+        expires_in = ast[:settings].find { |h| h[:macro] == :access_token_expires_in }
+        expires_in = expires_in[:values].first&.to_s if expires_in
 
         result = { detected: true }
         result[:grant_flows] = grant_flows if grant_flows
@@ -281,21 +288,30 @@ module RailsAiContext
       def extract_devise_settings
         path = File.join(app.root, "config", "initializers", "devise.rb")
         return {} unless File.exist?(path)
-        content = RailsAiContext::SafeFile.read(path)
-        return {} unless content
 
         settings = {}
-        settings[:timeout_in] = $1 if content.match(/config\.timeout_in\s*=\s*(\S+)/)
-        settings[:lock_strategy] = $1 if content.match(/config\.lock_strategy\s*=\s*:(\w+)/)
-        settings[:maximum_attempts] = $1.to_i if content.match(/config\.maximum_attempts\s*=\s*(\d+)/)
-        settings[:unlock_strategy] = $1 if content.match(/config\.unlock_strategy\s*=\s*:(\w+)/)
-        settings[:password_length] = $1 if content.match(/config\.password_length\s*=\s*(\S+)/)
-        settings.empty? ? {} : settings
+        config_assignments(path).each do |hit|
+          next unless hit[:assignment] && hit[:path].size == 1
+          key = hit[:path].first
+          next unless DEVISE_SETTINGS.include?(key)
+          settings[key] = devise_setting_value(key, hit)
+        end
+        settings
       rescue => e
         $stderr.puts "[rails-ai-context] extract_devise_settings failed: #{e.message}" if ENV["DEBUG"]
         {}
       end
 
+      def devise_setting_value(key, hit)
+        return hit[:value].to_s if SYMBOL_DEVISE_SETTINGS.include?(key)
+        return hit[:value] if key == :maximum_attempts && hit[:value].is_a?(Integer)
+        hit[:source]
+      end
+
+      def config_assignments(path)
+        SourceIntrospector.walk(path, { config: Listeners::ConfigAssignmentListener })[:config]
+      end
+
       def scan_models_for_devise
         models_dir = File.join(root, "app/models")
         return [] unless Dir.exist?(models_dir)

data/lib/rails_ai_context/introspectors/autoload_introspector.rb

@@ -6,6 +6,8 @@ module RailsAiContext
     # inflections, autoload/eager-load paths, collapsed dirs, and ignored
     # paths. Covers RAILS_NERVOUS_SYSTEM.md §3 (Autoloading - Zeitwerk).
     class AutoloadIntrospector
+      INFLECTION_DIRECTIVES = %i[acronym plural singular irregular uncountable human].freeze
+
       attr_reader :app
 
       def initialize(app)
@@ -102,20 +104,21 @@ module RailsAiContext
 
         inflections = []
         Dir.glob(File.join(dir, "*.rb")).sort.each do |path|
-          content = RailsAiContext::SafeFile.read(path) or next
           rel = path.sub("#{root}/", "")
+          ast = SourceIntrospector.walk(path, {
+            directives: -> { Listeners::ChainedCallListener.new(INFLECTION_DIRECTIVES, receiver: :inflect) },
+            chained:    -> { Listeners::ChainedCallListener.new(:inflect) },
+            bare:       -> { Listeners::GenericMacroListener.new(:inflect) }
+          })
 
           # inflect "api" => "API", "xml" => "XML"
-          content.scan(/inflect\(?\s*((?:["'][^"']+["']\s*=>\s*["'][^"']+["'],?\s*)+)/).each do |match|
-            pairs = match[0].scan(/["']([^"']+)["']\s*=>\s*["']([^"']+)["']/)
-            inflections.concat(pairs.map { |k, v| { file: rel, rule: "#{k} => #{v}" } })
+          (ast[:chained] + ast[:bare]).each do |hit|
+            hit[:options].each { |k, v| inflections << { file: rel, rule: "#{k} => #{v}" } }
           end
 
-          # inflect.acronym "API" / inflect.plural /…/, "…" / inflect.irregular "…", "…"
-          # Matches both inside `do |inflect|` blocks and via direct Inflector calls.
-          content.scan(/\binflect\.(acronym|plural|singular|irregular|uncountable|human)\s+["']([^"']+)["'](?:\s*,\s*["']([^"']+)["'])?/).each do |method, arg1, arg2|
-            rule = arg2 ? "#{method}: #{arg1} => #{arg2}" : "#{method}: #{arg1}"
-            inflections << { file: rel, rule: rule }
+          # inflect.acronym "API" / inflect.plural(/…/, "…") / inflect.irregular "…", "…"
+          ast[:directives].each do |hit|
+            inflections << { file: rel, rule: directive_rule(hit) }
           end
         end
         inflections.uniq
@@ -124,6 +127,12 @@ module RailsAiContext
         []
       end
 
+      def directive_rule(hit)
+        values = hit[:values].map(&:to_s)
+        return "#{hit[:method]}: #{values.first} => #{values.last}" if values.size > 1
+        "#{hit[:method]}: #{values.first}"
+      end
+
       def relativize(paths)
         Array(paths).map do |p|
           s = p.to_s

data/lib/rails_ai_context/introspectors/component_introspector.rb

@@ -51,16 +51,18 @@ module RailsAiContext
         class_name = extract_class_name(content)
         return nil unless class_name
 
+        structure = extract_structure(content)
+        type = detect_component_type(content)
         props = extract_props(content)
-        enum_values = extract_enum_values(content)
-        attach_enum_values_to_props(props, enum_values, content)
+        enum_values = extract_enum_values(structure)
+        attach_enum_values_to_props(props, enum_values, structure)
 
         component = {
           name: class_name,
           file: relative,
-          type: detect_component_type(content),
+          type: type,
           props: props,
-          slots: extract_slots(content)
+          slots: extract_slots(structure, type)
         }
 
         preview = find_preview(path, class_name)
@@ -235,70 +237,43 @@ module RailsAiContext
         nil
       end
 
-      def extract_slots(content)
-        slots = []
+      # Structural facts about the component class, grouped by kind so each
+      # consumer reads its own bucket instead of re-filtering the whole list.
+      def extract_structure(content)
+        results = SourceIntrospector.walk_source(content, {
+          structure: Listeners::ComponentStructureListener
+        })[:structure]
 
-        # Use AST for renders_one / renders_many detection
-        ast_data = SourceIntrospector.walk_source(content, {
-          slot_macros: -> { Listeners::GenericMacroListener.new(:renders_one, :renders_many) }
-        })
-
-        ast_data[:slot_macros].each do |macro|
-          slot_name = macro[:args]&.first&.to_s
-          next unless slot_name
-
-          type = macro[:macro] == :renders_one ? :one : :many
-          slot = { name: slot_name, type: type }
-
-          # Check if there's a renderer argument (second arg or options)
-          remaining_args = macro[:args][1..]
-          if remaining_args&.any?
-            slot[:renderer] = remaining_args.map(&:to_s).join(", ")
-          end
+        results.group_by { |entry| entry[:kind] }
+      end
 
-          slots << slot
+      def extract_slots(structure, type)
+        slots = structure.fetch(:slot_macro, []).map do |entry|
+          entry.slice(:name, :type, :renderer).compact
         end
 
-        # Phlex slots: def slot_name(&block) - keep regex for this (Phlex-specific, diminishing returns)
-        if detect_component_type(content) == :phlex
-          content.scan(/def\s+(\w+)\s*\(\s*&\s*\w*\s*\)/).each do |name,|
-            next if %w[initialize template view_template before_template after_template].include?(name)
-            slots << { name: name, type: :phlex_slot }
+        # Phlex slots are plain methods taking a block.
+        if type == :phlex
+          structure.fetch(:slot, []).each do |entry|
+            slots << { name: entry[:name], type: :phlex_slot }
           end
         end
 
         slots
       end
 
-      # Extracts enumerable values from constants and case statements.
-      # Returns a hash mapping downcased constant/variable names to arrays of symbol values.
-      # Detects three patterns:
-      #   1. Hash constants: VARIANTS = { primary: "...", secondary: "..." } -> keys
-      #   2. Array constants: SIZES = [:sm, :md, :lg] -> elements
-      #   3. Case statements: case @variant; when :primary; when :secondary -> when values
-      def extract_enum_values(content)
+      # Enumerable values a prop can take, keyed by downcased constant name
+      # (VARIANTS -> "variants") or by the instance variable a `case` branches on.
+      def extract_enum_values(structure)
         enums = {}
 
-        # Pattern 1: Hash constants - NAME = { key: "value", ... }
-        content.scan(/([A-Z][A-Z_0-9]*)\s*=\s*\{([^}]*)\}/m) do |name, body|
-          keys = body.scan(/(\w+):/).map(&:first)
-          enums[name.downcase] = keys if keys.any?
+        structure.fetch(:constant_table, []).each do |entry|
+          enums[entry[:name].downcase] = entry[:values]
         end
 
-        # Pattern 2: Array constants - NAME = [:sym, :sym, ...]
-        content.scan(/([A-Z][A-Z_0-9]*)\s*=\s*\[([^\]]*)\]/) do |name, body|
-          values = body.scan(/:(\w+)/).map(&:first)
-          enums[name.downcase] = values if values.any?
-        end
-
-        # Pattern 3: Case statements - case @ivar; when :val1 ... when :val2
-        # Use a non-greedy match that stops at the next `end`, `case`, or `def` keyword
-        content.scan(/case\s+@(\w+)\s*\n(.*?)(?=\n\s*(?:end|case|def)\b)/m) do |ivar, block|
-          values = block.scan(/when\s+:(\w+)/).map(&:first)
-          next if values.empty?
-          # Merge with existing values for same ivar (handles multiple case blocks)
-          existing = enums[ivar] || []
-          enums[ivar] = (existing + values).uniq
+        # Several case blocks can branch on the same ivar.
+        structure.fetch(:variant_branch, []).each do |entry|
+          enums[entry[:ivar]] = ((enums[entry[:ivar]] || []) + entry[:values]).uniq
         end
 
         enums
@@ -308,7 +283,7 @@ module RailsAiContext
       #   1. Direct ivar match: prop "variant" matches case @variant values
       #   2. Constant name match: prop "size" matches SIZES constant, prop "variant" matches VARIANTS constant
       #   3. Constant usage in initialize: @size referenced as SIZES[@size] matches prop "size"
-      def attach_enum_values_to_props(props, enum_values, content)
+      def attach_enum_values_to_props(props, enum_values, structure)
         props.each do |prop|
           name = prop[:name]
           values = nil
@@ -328,13 +303,14 @@ module RailsAiContext
             end
           end
 
-          # Constant usage match: find CONST[@ivar] patterns in the file
+          # Constant usage match: CONST[@ivar] ties the prop to that table
           unless values
-            content.scan(/([A-Z][A-Z_0-9]*)\[@#{name}\]/) do |const_name,|
-              if enum_values.key?(const_name.downcase)
-                values = enum_values[const_name.downcase]
-                break
-              end
+            structure.fetch(:constant_index, []).each do |entry|
+              next unless entry[:ivar] == name
+              table = enum_values[entry[:constant].downcase]
+              next unless table
+              values = table
+              break
             end
           end
 

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -117,7 +117,7 @@ module RailsAiContext
         source = RailsAiContext::SafeFile.read(path)
         return { error: "unreadable" } unless source
         parent = extract_parent_class_ast(source)
-        rate_limit_raw = extract_rate_limit(source)
+        rate_limit = rate_limit_entry(source)
         details = {
           parent_class: parent,
           api_controller: parent.include?("API"),
@@ -127,8 +127,8 @@ module RailsAiContext
           strong_params: extract_strong_params(source),
           respond_to_formats: extract_respond_to(source),
           rescue_from: extract_rescue_from(source),
-          rate_limit: rate_limit_raw,
-          rate_limit_parsed: parse_rate_limit(rate_limit_raw),
+          rate_limit: extract_rate_limit(source, rate_limit),
+          rate_limit_parsed: parse_rate_limit(rate_limit),
           turbo_stream_actions: extract_turbo_stream_actions(source)
         }.compact
         details
@@ -138,7 +138,7 @@ module RailsAiContext
 
       def extract_controller_details(ctrl)
         source = read_source(ctrl)
-        rate_limit_raw = extract_rate_limit(source)
+        rate_limit = rate_limit_entry(source)
 
         {
           parent_class: ctrl.superclass.name,
@@ -149,8 +149,8 @@ module RailsAiContext
           strong_params: extract_strong_params(source),
           respond_to_formats: extract_respond_to(source),
           rescue_from: extract_rescue_from(source),
-          rate_limit: rate_limit_raw,
-          rate_limit_parsed: parse_rate_limit(rate_limit_raw),
+          rate_limit: extract_rate_limit(source, rate_limit),
+          rate_limit_parsed: parse_rate_limit(rate_limit),
           turbo_stream_actions: extract_turbo_stream_actions(source)
         }.compact
       end
@@ -279,7 +279,11 @@ module RailsAiContext
             filter[:unless] = opts[:unless].to_s
           end
           if opts[:if]
-            filter[:if] = opts[:if].to_s
+            # A lambda has no literal value, so `opts[:if]` is "[INFERRED]".
+            # When the condition is an action_name comparison the AST can say
+            # exactly which action it names; report that instead of nothing.
+            actions = extract_action_condition(entry[:option_nodes][:if])
+            filter[:if] = actions ? %(action_name == "#{actions.first}") : opts[:if].to_s
           end
 
           filter
@@ -325,10 +329,28 @@ module RailsAiContext
         false
       end
 
-      def extract_action_condition(condition)
-        return nil unless condition.is_a?(String) || condition.respond_to?(:to_s)
-        match = condition.to_s.match(/action_name\s*==\s*['"](\w+)['"]/)
-        match ? [ match[1] ] : nil
+      # `if: -> { action_name == "create" }` narrows a filter to one action the
+      # same way `only:` does. Returns the action name, or nil for any other
+      # condition.
+      def extract_action_condition(node)
+        node = lambda_body(node)
+        return nil unless node.is_a?(Prism::CallNode) && node.name == :==
+
+        receiver = node.receiver
+        return nil unless receiver.is_a?(Prism::CallNode) && receiver.name == :action_name && receiver.receiver.nil?
+
+        operand = node.arguments&.arguments&.first
+        case operand
+        when Prism::StringNode then [ operand.unescaped ]
+        when Prism::SymbolNode then [ operand.value.to_s ]
+        end
+      end
+
+      def lambda_body(node)
+        return node unless node.is_a?(Prism::LambdaNode) || node.is_a?(Prism::BlockNode)
+        statements = node.body
+        return nil unless statements.is_a?(Prism::StatementsNode) && statements.body.size == 1
+        statements.body.first
       end
 
       def extract_concerns(ctrl)
@@ -655,16 +677,21 @@ module RailsAiContext
         node.child_nodes.compact.each { |child| find_call_at_line(child, method_name, line_number, constants) }
       end
 
-      def extract_rate_limit(source)
+      def rate_limit_entry(source)
         return nil if source.nil?
 
         ast_result = SourceIntrospector.walk_source(source, {
           rate_limit: -> { Listeners::GenericMacroListener.new(:rate_limit) }
         })
-        entries = ast_result[:rate_limit] || []
-        return nil if entries.empty?
+        (ast_result[:rate_limit] || []).first
+      rescue => e
+        $stderr.puts "[rails-ai-context] rate_limit_entry failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
+      def extract_rate_limit(source, entry)
+        return nil unless entry
 
-        entry = entries.first
         line_num = entry[:location]
         lines = source.lines
         return nil unless line_num && line_num > 0 && line_num <= lines.size
@@ -676,13 +703,16 @@ module RailsAiContext
         nil
       end
 
-      def parse_rate_limit(rate_limit_raw)
-        return nil if rate_limit_raw.nil?
+      def parse_rate_limit(entry)
+        return nil unless entry
+
+        options = entry[:options] || {}
+        sources = entry[:option_values] || {}
 
         parsed = {}
-        parsed[:to] = $1.to_i if rate_limit_raw.match(/to:\s*(\d+)/)
-        parsed[:within] = $1 if rate_limit_raw.match(/within:\s*(\S+)/)
-        parsed[:only] = $1.scan(/:(\w+)/).flatten if rate_limit_raw.match(/only:\s*(.+?)(?:,\s*\w+:|$)/)
+        parsed[:to] = options[:to] if options[:to].is_a?(Integer)
+        parsed[:within] = sources[:within].to_s if sources.key?(:within)
+        parsed[:only] = Array(options[:only]).map(&:to_s) if options.key?(:only)
 
         parsed.empty? ? nil : parsed
       rescue => e

data/lib/rails_ai_context/introspectors/initializer_introspector.rb

@@ -66,11 +66,16 @@ module RailsAiContext
         return [] unless Dir.exist?(dir)
 
         Dir.glob(File.join(dir, "*.rb")).sort.filter_map do |path|
-          content = RailsAiContext::SafeFile.read(path) or next
-          initializer_count = content.scan(/^\s*initializer\s+["']/).size
+          next unless RailsAiContext::SafeFile.read(path)
+
+          ast = SourceIntrospector.walk(path, {
+            initializers: -> { Listeners::GenericMacroListener.new(:initializer) },
+            config:       Listeners::ConfigAssignmentListener
+          })
+
           entry = { file: path.sub("#{root}/", "") }
-          entry[:initializers] = initializer_count if initializer_count > 0
-          entry[:setup_calls]  = content.scan(/^\s*config\.(\w+)/).flatten.uniq.first(10)
+          entry[:initializers] = ast[:initializers].size if ast[:initializers].any?
+          entry[:setup_calls]  = ast[:config].map { |hit| hit[:path].first.to_s }.uniq.first(10)
           entry
         end
       end