rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/tools/get_component_catalog.rb

@@ -47,7 +47,7 @@ module RailsAiContext
             component = component.to_s.strip
 
             if components.empty?
-              note = api_only_note("app/components")
+              note = api_only_note("app/components", dir: "app/components")
               return text_response(note) if note
 
               return text_response("Component '#{component}' not found - no components exist in app/components/. Create ViewComponent or Phlex components first.")
@@ -63,7 +63,7 @@ module RailsAiContext
             text_response(render_single(found.first, detail))
           else
             if components.empty?
-              note = api_only_note("app/components")
+              note = api_only_note("app/components", dir: "app/components")
               return text_response(note) if note
 
               return text_response(
@@ -210,8 +210,11 @@ module RailsAiContext
           else
             result = "<%= render #{name}.new#{init == ".new" ? "" : init} do |c| %>"
             slots.each do |slot|
-              if slot[:type] == :many
-                result += "\n  <% c.with_#{slot[:name]} do %>item<% end %>"
+              if slot[:setters]
+                filler = slot[:type] == :many ? "item" : "content"
+                slot[:setters].each { |setter| result += "\n  <% c.with_#{setter} do %>#{filler}<% end %>" }
+              elsif slot[:type] == :many
+                result += "\n  <% c.with_#{slot[:name].to_s.singularize} do %>item<% end %>"
               else
                 result += "\n  <% c.with_#{slot[:name]} do %>content<% end %>"
               end

data/lib/rails_ai_context/tools/get_concern.rb

@@ -171,8 +171,8 @@ module RailsAiContext
         end
 
         # Only the module's own mixins: a class nested in the file includes for itself.
-        mixins = ConcernMembership.own_mixins(
-          Introspectors::SourceIntrospector.walk_source(source, { mixins: Introspectors::Listeners::MixinsListener })[:mixins], name
+        mixins = ConcernMembership.owned_by(
+          Introspectors::SourceIntrospector.walk_source(source, { mixins: Introspectors::Listeners::MixinsListener })[:mixins], name, root: root
         )
         included_modules = mixins.select { |m| m[:macro] == :include }.map { |m| m[:name] }.uniq
         extended_modules = mixins.select { |m| m[:macro] == :extend }.map { |m| m[:name] }.uniq
@@ -190,14 +190,16 @@ module RailsAiContext
           macros.each { |m| lines << "- #{m}" }
         end
 
-        public_methods = Introspectors::ActionResolver.public_methods_from_source(source, owner: name)
+        public_methods = unique(Introspectors::ActionResolver.public_methods_in(source, owner: name))
         class_methods = concern_class_methods(source, name)
+        own_module_methods = module_methods(source, name)
         render_methods(lines, source, detail, "Public Methods", public_methods)
-        render_methods(lines, source, detail, "Class Methods", class_methods, self_prefix: true)
+        render_methods(lines, source, detail, "Class Methods", class_methods)
+        render_methods(lines, source, detail, "Module Methods", own_module_methods)
         # A module of private helpers is not an empty one.
-        if public_methods.empty? && class_methods.empty?
+        if public_methods.empty? && class_methods.empty? && own_module_methods.empty?
           render_methods(lines, source, detail, "Private Methods",
-            Introspectors::ActionResolver.private_methods_from_source(source, owner: name))
+            unique(Introspectors::ActionResolver.private_methods_in(source, owner: name)))
         end
 
         # Parse callbacks defined in the concern
@@ -246,29 +248,40 @@ module RailsAiContext
         text_response(lines.join("\n"))
       end
 
-      # A class method is written `def self.x` but listed as `x`, so its body
-      # is only found under the prefixed name.
-      private_class_method def self.render_methods(lines, source, detail, title, methods, self_prefix: false)
+      # The body comes from this def's own walked bounds, so a same-named private method or delegate is never shown.
+      private_class_method def self.render_methods(lines, source, detail, title, methods)
         return if methods.empty?
 
         lines << "" << "## #{title}"
         full = RailsAiContext::DetailLevel.full?(detail)
         methods.each do |m|
-          method_name = m.to_s.split("(").first
-          body = full && (extract_method_source_from_string(source, method_name) ||
-            (self_prefix ? extract_method_source_from_string(source, "self.#{method_name}") : nil))
+          signature = Introspectors::ActionResolver.signature(m)
+          body = full && Introspectors::ActionResolver.body_of(source, m)
           if body
-            lines << "### #{m}" << "```ruby" << body[:code] << "```" << ""
+            lines << "### #{signature}" << "```ruby" << body[:code] << "```" << ""
           else
-            lines << "- `#{m}`"
+            lines << "- `#{signature}`"
           end
         end
       end
 
       # `module ClassMethods` defs count too: ActiveSupport::Concern extends the includer with it.
       private_class_method def self.concern_class_methods(source, name)
-        (Introspectors::ActionResolver.class_methods_from_source(source, owner: name) +
-          Introspectors::ActionResolver.public_methods_from_source(source, owner: "#{name}::ClassMethods")).uniq
+        gained = own_class_methods(source, name).select { |m| m[:class_methods_block] }
+        unique(gained + Introspectors::ActionResolver.public_methods_in(source, owner: "#{name}::ClassMethods"))
+      end
+
+      # `def self.x` and `class << self` methods live on the module; no includer gains them, nor a mixin hook.
+      private_class_method def self.module_methods(source, name)
+        unique(own_class_methods(source, name).reject { |m| m[:class_methods_block] || ConcernMembership::MIXIN_HOOKS.include?(m[:name]) })
+      end
+
+      private_class_method def self.unique(methods)
+        methods.uniq { |m| Introspectors::ActionResolver.signature(m) }
+      end
+
+      private_class_method def self.own_class_methods(source, name)
+        Introspectors::ActionResolver.own_methods_in(source, name).select { |m| m[:scope] == :class && m[:visibility] == :public }
       end
 
       private_class_method def self.methods_phrase(concern)
@@ -299,7 +312,7 @@ module RailsAiContext
           if source
             public_methods = Introspectors::ActionResolver.public_methods_from_source(source, owner: concern_name)
             class_methods = concern_class_methods(source, concern_name)
-            method_count = public_methods.size + class_methods.size
+            method_count = public_methods.size + class_methods.size + module_methods(source, concern_name).size
             private_count = Introspectors::ActionResolver.private_methods_from_source(source, owner: concern_name).size if method_count.zero?
           end
 
@@ -507,7 +520,7 @@ module RailsAiContext
         sources = includer_dirs(root).flat_map { |dir| safe_glob(dir, "**/*.rb", real_root) }.uniq
           .reject { |file_path| file_path.include?("/concerns/") }
           .filter_map { |file_path| (source = RailsAiContext::SafeFile.read(file_path)) && [ file_path, source ] }
-        Introspectors::Includers.of(root, sources, [ concern_name ], macros: %i[include]).values.flatten.uniq.sort
+        Introspectors::Includers.of(root, sources, [ concern_name ], macros: %i[include prepend]).values.flatten.uniq.sort
       rescue => e
         RailsAiContext.debug_fail(e, [], label: "find_includers")
       end

data/lib/rails_ai_context/tools/get_config.rb

@@ -19,6 +19,10 @@ module RailsAiContext
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
       def self.call(server_context: nil)
+        if static_refusal_for(:config) && (rackup = rackup_lines).any?
+          return text_response(([ unavailable_text ] + rackup).join("\n"))
+        end
+
         fetch_section(:config, subject: "Config introspection", remedy: "Add :config to introspectors or use `config.preset = :full`.") do |data|
           lines = [ "# Application Configuration", "" ]
 
@@ -59,6 +63,7 @@ module RailsAiContext
           end
 
           lines.concat(middleware_lines(data[:middleware_stack]))
+          lines.concat(rackup_lines)
 
           if data[:initializers]&.any?
             # List every initializer - stock ones often carry active code
@@ -72,13 +77,23 @@ module RailsAiContext
 
           if data[:current_attributes]&.any?
             lines << "" << "## CurrentAttributes"
-            data[:current_attributes].each { |c| lines << "- `#{c}`" }
+            data[:current_attributes].each { |c| lines << current_attributes_line(c, data.dig(:current_attribute_details, c)) }
           end
 
           text_response(lines.join("\n"))
         end
       end
 
+      private_class_method def self.current_attributes_line(name, detail)
+        line = "- `#{name}`"
+        return line unless detail
+
+        attributes = Array(detail[:attributes]).map { |a| a[:default] ? "#{a[:name]} (default `#{a[:default]}`)" : a[:name] }
+        line += ": #{attributes.join(', ')}" if attributes.any?
+        line += "; hooks: #{detail[:hooks].map { |h| "`#{h}`" }.join(', ')}" if Array(detail[:hooks]).any?
+        line
+      end
+
       # Middleware Rails or a development gem puts in every stack.
       DEV_MIDDLEWARE = %w[
         Propshaft::Server WebConsole::Middleware ActionDispatch::Reloader
@@ -110,6 +125,30 @@ module RailsAiContext
         lines
       end
 
+      # The static refusal reads config.ru alone rather than building every section,
+      # and only when the middleware introspector the booted tier reads it through is on.
+      private_class_method def self.rackup_lines
+        calls = if RailsAiContext.static_tier?
+          RailsAiContext.configuration.introspectors.include?(:middleware) ? Introspectors::MiddlewareIntrospector.rackup(rails_app.root.to_s) : []
+        else
+          Array(Payload.section(cached_context, :middleware)&.dig(:rackup))
+        end
+        return [] if calls.empty?
+
+        lines = [ "", "## config.ru (runs before the Rails middleware stack)" ]
+        calls.each do |call|
+          next lines << "- not read: #{call[:unread]}, so the middleware it adds is unknown" if call[:unread]
+
+          where = [ "line #{call[:line]}", ("inside `map #{call[:within]}`" if call[:within]), call[:condition] ].compact.join(", ")
+          lines << if call[:call] == "map"
+            "- `map #{call[:target]}` (#{where}) - its own Rack app; requests under it never reach Rails' router"
+          else
+            "- `use #{call[:target]}` (#{where})"
+          end
+        end
+        lines
+      end
+
       # What the middleware introspector found the app owns, by class name.
       private_class_method def self.owned_middleware
         Array(Payload.section(cached_context, :middleware)&.dig(:custom_middleware))
@@ -155,9 +194,11 @@ module RailsAiContext
       end
 
       private_class_method def self.detect_database
-        adapter = Rails.configuration.database_configuration&.dig(Rails.env, "adapter") rescue nil
-        return nil unless adapter
-        adapter
+        env = Rails.configuration.database_configuration&.dig(Rails.env) rescue nil
+        return nil unless env.is_a?(Hash)
+
+        # A multi-database environment nests one block per database; primary is the app's own.
+        env["adapter"] || (env["primary"] || env.values.find { |v| v.is_a?(Hash) })&.dig("adapter")
       end
 
       private_class_method def self.detect_auth_framework
@@ -214,23 +255,16 @@ module RailsAiContext
         parts.any? ? parts.join(", ") : nil
       end
 
+      # Action Cable's railtie loads the current environment's cable.yml block into
+      # the server config; config.action_cable has no adapter of its own.
       private_class_method def self.detect_action_cable
-        # Try Rails config API first
-        if defined?(ActionCable) && Rails.application.config.respond_to?(:action_cable)
-          cable_config = Rails.application.config.action_cable
-          adapter = cable_config.adapter if cable_config.respond_to?(:adapter)
-          return adapter.to_s if adapter && !adapter.to_s.empty?
-        end
-
-        # YAML fallback for older Rails or when config API isn't available
-        cable_yml = rails_app.root.join("config/cable.yml")
-        return nil unless File.exist?(cable_yml)
+        return nil unless defined?(ActionCable) && ActionCable.respond_to?(:server)
 
-        content = RailsAiContext::SafeFile.read(cable_yml)
-        return nil unless content
+        cable = ActionCable.server.config.cable
+        return nil unless cable
 
-        adapter = content.match(/adapter:\s*(\w+)/)&.captures&.first
-        adapter || "configured"
+        adapter = cable[:adapter] || cable["adapter"]
+        adapter.to_s.empty? ? "configured" : adapter.to_s
       rescue StandardError
         nil
       end

data/lib/rails_ai_context/tools/get_controllers.rb

@@ -56,8 +56,9 @@ module RailsAiContext
             key = Payload.find_controller(ctx, controller) || controller
             info = controllers[key]
             unless info
+              recovery = "Call rails_get_controllers(detail:\"summary\") to see all controllers"
               return not_found_response("Controller", controller, app_controller_names,
-                recovery_tool: "Call rails_get_controllers(detail:\"summary\") to see all controllers")
+                recovery_tool: data[:unread_engine] ? "#{unread_engine_line(data)} #{recovery}" : recovery)
             end
             return text_response("Error inspecting #{key}: #{info[:error]}") if info[:error]
 
@@ -85,7 +86,7 @@ module RailsAiContext
           # Listing mode
           case detail
           when "summary"
-            lines = [ "# Controllers (#{page[:total]})", "" ]
+            lines = listing_header(page, data)
             paginated_names.each do |name|
               info = app_controllers[name]
               action_count = info[:actions]&.size || 0
@@ -96,7 +97,7 @@ module RailsAiContext
             text_response(lines.join("\n"))
 
           when "standard"
-            lines = [ "# Controllers (#{page[:total]})", "" ]
+            lines = listing_header(page, data)
             paginated_names.each do |name|
               info = app_controllers[name]
               lines << "- **#{name}** - #{Serializers::SectionFacts.actions_phrase(info)}"
@@ -105,7 +106,7 @@ module RailsAiContext
             text_response(lines.join("\n"))
 
           when "full"
-            lines = [ "# Controllers (#{page[:total]})", "" ]
+            lines = listing_header(page, data)
 
             # Group sibling controllers that share the same parent and identical structure
             paginated_ctrl = app_controllers.select { |k, _| paginated_names.include?(k) }
@@ -151,7 +152,9 @@ module RailsAiContext
                     info, rescue_handlers: true,
                     ctx: ctx, name: name, root: rails_app&.root&.to_s
                   ))
-                  lines << "- Rate limit: #{info[:rate_limit]}" if info[:rate_limit]
+                  # An inherited limit is named with its base in the controller's own detail.
+                  own_limits = Array(info[:rate_limits]).reject { |limit| limit[:from] }
+                  lines << "- Rate limit: #{own_limits.map { |limit| limit[:text] }.join('; ')}" if own_limits.any?
                   lines << "- Turbo Stream actions: #{info[:turbo_stream_actions].join(', ')}" if info[:turbo_stream_actions]&.any?
                   lines << ""
                 end
@@ -174,6 +177,14 @@ module RailsAiContext
         )
       end
 
+      private_class_method def self.listing_header(page, data)
+        [ "# Controllers (#{page[:total]})", "", *(data[:unread_engine] ? [ unread_engine_line(data), "" ] : []) ]
+      end
+
+      private_class_method def self.unread_engine_line(data)
+        "The engine at `#{data[:unread_engine]}` is not read unbooted, so its controllers are not listed; boot the app to read them."
+      end
+
       # A class that defines no action of its own is an answer, and dropping
       # the line left it reading as a walk that did not look. An unread entry
       # already gets a line of its own, so it is not said twice.
@@ -234,8 +245,7 @@ module RailsAiContext
 
         if applicable.values.any?(&:any?)
           lines << "" << "## Applicable Filters"
-          applicable[:inherited].each { |f| lines << filter_line(f) }
-          applicable[:own].each { |f| lines << filter_line(f) }
+          applicable[:chain].each { |f| lines << filter_line(f) }
           applicable[:skipped].each { |name| lines << "- ~~#{name}~~ _(skipped)_" }
         end
 
@@ -289,9 +299,11 @@ module RailsAiContext
                 lines << "- requires: `:#{sp[:requires]}`" if sp[:requires]
                 lines << "- permits: #{sp[:permits].map { |p| "`:#{p}`" }.join(', ')}" if sp[:permits]&.any?
                 sp[:nested]&.each do |key, fields|
-                  lines << "- nested `#{key}:` #{fields.map { |f| "`:#{f}`" }.join(', ')}"
+                  members = fields.is_a?(Hash) ? fields.map { |inner, v| permit_field_text({ inner => v }) } : fields.map { |f| permit_field_text(f, braced: true) }
+                  lines << "- nested `#{key}:` #{members.map { |m| "`#{m}`" }.join(', ')}"
                 end
                 sp[:arrays]&.each { |a| lines << "- array: `#{a}: []`" }
+                sp[:hashes]&.each { |h| lines << "- hash: `#{h}: {}`" }
               end
               body = extract_method_with_lines(source_path, sp[:name], source: source, owner: controller_name)
               lines << "```ruby" << body[:code] << "```" if body
@@ -359,6 +371,20 @@ module RailsAiContext
         end
       end
 
+      # One field of a permit list as Ruby spells it: `:name`, `[...]`, `key: [...]`, `key: {}` or `key: { ... }`, braced inside a list.
+      private_class_method def self.permit_field_text(field, braced: false)
+        return "[#{field.map { |f| permit_field_text(f, braced: true) }.join(', ')}]" if field.is_a?(Array)
+        return ":#{field}" unless field.is_a?(Hash)
+
+        key, value = field.first
+        text = if value.is_a?(Hash)
+          value.empty? ? "#{key}: {}" : "#{key}: { #{value.map { |inner, v| permit_field_text({ inner => v }) }.join(', ')} }"
+        else
+          "#{key}: [#{value.map { |f| permit_field_text(f, braced: true) }.join(', ')}]"
+        end
+        braced ? "{ #{text} }" : text
+      end
+
       private_class_method def self.filter_line(filter)
         line = "- `#{filter[:kind]}` **#{filter[:name]}**#{Serializers::SectionFacts.filter_origin(filter)}"
         line += " (only: #{filter[:only].join(', ')})" if filter[:only]&.any?
@@ -438,6 +464,8 @@ module RailsAiContext
         lines << "**Parent:** `#{resolved_parent(name, info, ctx)}`" if info[:parent_class]
         lines << "**API controller:** yes" if info[:api_controller]
         lines << "**Formats:** #{info[:respond_to_formats].join(', ')}" if info[:respond_to_formats]&.any?
+        declared = RailsAiContext::Introspectors::ControllerSettings.resolve(ctx, name, root: rails_app.root.to_s)
+        lines << "**Layout:** #{RailsAiContext::Introspectors::ControllerSettings.layout_phrase(declared[:layout])}" if declared[:layout]
 
         lines << "" << "## Actions"
         lines << if info[:actions]&.any?
@@ -449,21 +477,23 @@ module RailsAiContext
         chain = RailsAiContext::ActionFilters.for_controller(ctx, name, root: rails_app.root.to_s)
         if chain.values.any?(&:any?)
           lines << "" << "## Filters"
-          chain[:inherited].each { |f| lines << filter_line(f) }
-          chain[:own].each { |f| lines << filter_line(f) }
+          chain[:chain].each { |f| lines << filter_line(f) }
           chain[:skipped].each { |skipped| lines << "- ~~#{skipped}~~ _(skipped)_" }
         end
         if info[:concerns_unread]&.any?
           lines << "" << "_#{RailsAiContext::Confidence::UNAVAILABLE} " \
                          "#{CountPhrase.call(info[:concerns_unread].size, "included module")} not read, " \
-                         "so a filter declared there is missing from this list: #{info[:concerns_unread].join(', ')}_"
+                         "so a filter declared there would be missing from this list: #{info[:concerns_unread].join(', ')}_"
         end
 
         if info[:strong_params]&.any?
           lines << "" << "## Strong Params"
           info[:strong_params].each do |sp|
             if sp.is_a?(Hash)
-              permits_summary = sp[:permits]&.map { |p| ":#{p}" }&.join(", ") || ""
+              permits_summary = (Array(sp[:permits]).map { |p| ":#{p}" } +
+                                 Array(sp[:nested]).map { |key, fields| permit_field_text({ key => fields }) } +
+                                 Array(sp[:arrays]).map { |key| "#{key}: []" } +
+                                 Array(sp[:hashes]).map { |key| "#{key}: {}" }).join(", ")
               lines << "- `#{sp[:name]}`#{sp[:requires] ? " (requires: :#{sp[:requires]})" : ""}#{permits_summary.empty? ? "" : " permits: #{permits_summary}"}"
             else
               lines << "- `#{sp}`"
@@ -471,6 +501,14 @@ module RailsAiContext
           end
         end
 
+        if declared[:settings].any?
+          lines << "" << "## Settings"
+          declared[:settings].each do |setting|
+            origin = [ ("from #{setting[:from]}" unless setting[:from] == name), ("through #{setting[:via]}" if setting[:via]) ].compact
+            lines << "- `#{setting[:text]}`#{" _(#{origin.join(' ')})_" if origin.any?}"
+          end
+        end
+
         # Rescue handlers
         if info[:rescue_from]&.any?
           lines << "" << "## Rescue Handlers"
@@ -478,7 +516,13 @@ module RailsAiContext
         end
 
         # Rate limiting
-        lines << "" << "**Rate limit:** #{info[:rate_limit]}" if info[:rate_limit]
+        limits = Array(info[:rate_limits]).map { |limit| "#{limit[:text]}#{" _(from #{limit[:from]})_" if limit[:from]}" }
+        if limits.one?
+          lines << "" << "**Rate limit:** #{limits.first}"
+        elsif limits.any?
+          lines << "" << "**Rate limits:**"
+          limits.each { |limit| lines << "- #{limit}" }
+        end
 
         # Turbo Stream actions
         if info[:turbo_stream_actions]&.any?

data/lib/rails_ai_context/tools/get_conventions.rb

@@ -64,6 +64,12 @@ module RailsAiContext
             end
           end
 
+          admin = Introspectors::AdminResources.call(rails_app.root)
+          if admin.any?
+            lines << "" << "## Admin Resources"
+            admin.each { |resource| lines << "- #{Introspectors::AdminResources.line(resource)}" }
+          end
+
           # Config files - only show non-obvious ones (skip files every Rails app has)
           if conventions[:config_files]&.any?
             obvious = %w[
@@ -164,6 +170,7 @@ module RailsAiContext
         [ "esbuild", %w[esbuild] ],
         [ "Vite", %w[vite] ],
         [ "Webpack", %w[webpack] ],
+        [ "Rollup", %w[rollup] ],
         [ "React", %w[react] ],
         [ "Vue", %w[vue] ],
         [ "Svelte", %w[svelte @sveltejs/kit] ],
@@ -174,26 +181,17 @@ module RailsAiContext
 
       private_class_method def self.detect_frontend_stack
         root = rails_app.root.to_s
-        return [] unless File.exist?(File.join(root, "package.json"))
-
+        css = Introspectors::AssetPipelineIntrospector.css_framework_label(root)
         stack = STACK_MARKERS.filter_map do |label, packages|
-          label if packages.any? { |pkg| RailsAiContext::PackageJson.present?(root, pkg) }
+          label if label == css || packages.any? { |pkg| RailsAiContext::PackageJson.present?(root, pkg) }
         end
 
-        pm = detect_package_manager
+        pm = RailsAiContext::PackageJson.package_manager(root)&.first
         stack << "#{pm} (package manager)" if pm
 
         stack
       end
 
-      private_class_method def self.detect_package_manager
-        return "pnpm" if File.exist?(rails_app.root.join("pnpm-lock.yaml"))
-        return "yarn" if File.exist?(rails_app.root.join("yarn.lock"))
-        return "bun" if File.exist?(rails_app.root.join("bun.lockb"))
-        return "npm" if File.exist?(rails_app.root.join("package-lock.json"))
-        nil
-      end
-
       # Scan controllers for app-specific authorization, flash, and error-handling patterns
       private_class_method def self.detect_app_patterns
         controllers_dir = rails_app.root.join("app", "controllers").to_s
@@ -224,19 +222,17 @@ module RailsAiContext
           flash_alerts.concat(content.scan(/alert:\s*"([^"]*)"/).flatten)
 
           # Not-found handling: set_* methods that rescue or redirect on missing records
-          content.scan(/def\s+(set_\w+).*?(?=\n\s*def\s|\n\s*end\s*\z)/m).each do |match_data|
-            method_name = match_data[0]
-            # Look for the block around this method for rescue/redirect
-            if content.match?(/def\s+#{Regexp.escape(method_name)}.*?(?:rescue\s+ActiveRecord::RecordNotFound|rescue\b)/m)
-              redirect_match = content.match(/def\s+#{Regexp.escape(method_name)}.*?redirect_to\s+(\S+)/m)
+          content.scan(/def\s+(set_\w+)(.*?)(?=\n\s*def\s|\n\s*end\s*\z)/m).each do |method_name, body|
+            if body.match?(/\brescue\b/)
+              redirect_match = body.match(/redirect_to\s+(\S+)/)
               target = redirect_match ? redirect_match[1].sub(/,.*/, "") : "..."
               not_found_patterns << "#{method_name} → rescue → redirect_to #{target}" unless not_found_patterns.include?("#{method_name} → rescue → redirect_to #{target}")
             end
           end
 
           # Create action flow detection
-          if content.match?(/def\s+create\b/)
-            create_block = content[/def\s+create\b.*?(?=\n\s{2}def\s|\n\s{2}private|\z)/m]
+          if content.match?(/def\s+create#{RailsAiContext::MethodName.definition_end("create")}/)
+            create_block = content[/def\s+create#{RailsAiContext::MethodName.definition_end("create")}.*?(?=\n\s{2}def\s|\n\s{2}private|\z)/m]
             if create_block
               flow_parts = []
               flow_parts << "permission check" if create_block.match?(/can_\w+\??|authorize|authorize!/)
@@ -395,7 +391,7 @@ module RailsAiContext
         return info unless Dir.exist?(locales_dir)
 
         real_root = File.realpath(rails_app.root).to_s
-        locale_files = safe_glob(locales_dir, "**/*.{yml,yaml,rb}", real_root)
+        locale_files = safe_glob(locales_dir, Introspectors::I18nIntrospector::RAILS_LOCALE_GLOB, real_root)
         # The locales each file declares, as the i18n section read them; a
         # file's name gives the locale only as its last part (devise.en.yml).
         read = RailsAiContext::Payload.section(cached_context, :i18n)&.dig(:locale_files)
@@ -451,7 +447,7 @@ module RailsAiContext
 
       TEST_SIGNALS = {
         devise: /Devise::Test::IntegrationHelpers/,
-        sign_in: /sign_in/,
+        sign_in: /\bsign_in(?:_as)?\b/,
         assert_select: /assert_select/,
         assert_response: /assert_response/,
         auth_test: /requires?\s+authentication/i
@@ -469,6 +465,7 @@ module RailsAiContext
 
         found = {}
         detected_in = []
+        sign_in = nil
 
         test_files.first(5).each do |path|
           content = RailsAiContext::SafeFile.read(path) or next
@@ -476,6 +473,7 @@ module RailsAiContext
           next if hits.empty?
 
           found.update(hits)
+          sign_in ||= sign_in_call(content) if hits[:sign_in]
           # Only credit files that actually contributed a signal - an empty
           # scaffold test says nothing about the app's test pattern.
           detected_in << File.basename(path, ".rb").camelize.sub(/Test$/, "")
@@ -498,7 +496,7 @@ module RailsAiContext
           sections << ""
         end
         sections << "  test \"[action] renders page\" do"
-        sections << "    sign_in users(:one)" if found[:sign_in]
+        sections << "    #{sign_in}" if sign_in
         sections << "    get [path]"
         sections << "    assert_response :success"
         sections << "    assert_select \"h1\", \"[Expected Title]\"" if found[:assert_select]
@@ -512,6 +510,30 @@ module RailsAiContext
       rescue => e
         RailsAiContext.debug_fail(e, [], label: "detect_test_pattern")
       end
+
+      # A variable or a bare helper name: set outside the call, so a copy of
+      # the call alone signs in nil.
+      SIGN_IN_BOUND_OUTSIDE = /\A(?:@@?|\$)?[a-z_]\w*\z/
+      private_constant :SIGN_IN_BOUND_OUTSIDE
+
+      # The first sign-in call as the test writes it: Devise's `sign_in` and
+      # the `sign_in_as` Rails 8.1's authentication generator defines take
+      # different arguments. An argument the skeleton never sets is swapped
+      # for the app's own users fixture.
+      private_class_method def self.sign_in_call(content)
+        hit = RailsAiContext::Introspectors::SourceIntrospector.walk_source(content, {
+          sign_in: -> { RailsAiContext::Introspectors::Listeners::GenericMacroListener.new(:sign_in, :sign_in_as) }
+        })[:sign_in].first or return nil
+
+        call = content.byteslice(hit[:offset], hit[:end_offset] - hit[:offset]).squish
+        arg = hit[:values].first
+        return call unless arg.is_a?(String) && arg.match?(SIGN_IN_BOUND_OUTSIDE)
+
+        key = fixture_key_for("users", RailsAiContext::Payload.section(cached_context, :tests) || {})
+        return "# TODO: #{hit[:macro]} a user built from this app's own test data" unless key
+
+        call.sub(/(?<![\w@$])#{Regexp.escape(arg)}(?![\w?!])/, "users(:#{key})")
+      end
     end
   end
 end

data/lib/rails_ai_context/tools/get_engines.rb

@@ -31,6 +31,7 @@ module RailsAiContext
           if mounted.any?
             mounted.each do |e|
               line = e[:path] ? "- **#{e[:engine]}** at `#{e[:path]}`" : "- **#{e[:engine]}**"
+              line += " (`#{e[:condition]}`)" if e[:condition]
               line += " (#{e[:category]})" if e[:category]
               line += " - #{e[:description]}" if e[:description]
               lines << line
@@ -56,6 +57,7 @@ module RailsAiContext
             loaded.each do |e|
               parts = []
               parts << count_phrase(e[:route_count], "route") if e[:route_count]
+              parts << count_phrase(e[:dynamic_route_count], "redirect or lambda route") if e[:dynamic_route_count]
               parts << count_phrase(e[:model_count], "model") if e[:model_count]
               line = "- **#{e[:name]}**"
               line += " - #{parts.join(', ')}" if parts.any?