rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/tools/get_helper_methods.rb

@@ -204,11 +204,15 @@ module RailsAiContext
           end
         end
 
-        # Cross-reference hints
-        controller_name = underscore.split("/").last
-        lines << ""
-        lines << "_Next: `rails_get_view(controller:\"#{controller_name}\")` for views"
-        lines << " | `rails_get_controllers(controller:\"#{controller_name.camelize}Controller\")` for controller_"
+        # Cross-reference hints, to the views and the controller the helper is
+        # named for, and only those the app has: ApplicationHelper has no
+        # controller of its own to send the reader to.
+        route_key = relative_under(file_path, helper_dirs).delete_suffix(".rb").delete_suffix("_helper")
+        hints = []
+        hints << "`rails_get_view(controller:\"#{route_key}\")` for views" if RailsAiContext::PathResolver.view_dirs(root).any? { |dir| Dir.exist?(File.join(dir, route_key)) }
+        controller = Payload.controller_for_route_key(cached_context, route_key)&.first
+        hints << "`rails_get_controllers(controller:\"#{controller}\")` for controller" if controller
+        lines << "" << "_Next: #{hints.join(' | ')}_" if hints.any?
 
         text_response(lines.join("\n"))
       end
@@ -229,7 +233,7 @@ module RailsAiContext
           }
         end
 
-        sorted = helpers_data.sort_by { |h| -h[:method_count] }
+        sorted = helpers_data.sort_by.with_index { |h, i| [ -h[:method_count], i ] }
         page = paginate(sorted, offset: offset, limit: limit, default_limit: 50)
         declared = controller_helper_methods(root)
 

data/lib/rails_ai_context/tools/get_i18n.rb

@@ -132,7 +132,7 @@ module RailsAiContext
             lines << "- **Fallbacks:** #{Array(fallbacks[locale.to_sym] || fallbacks[locale]).join(', ')}"
           end
 
-          render_file_list(lines, page, "Files for #{locale}", "_No locale files found for '#{locale}'._")
+          render_file_list(lines, page, "Files for #{echo_input(locale)}", "_No locale files found for '#{echo_input(locale)}'._")
           text_response(lines.join("\n"))
         end
 

data/lib/rails_ai_context/tools/get_job_pattern.rb

@@ -417,7 +417,7 @@ module RailsAiContext
         # Queue summary
         # An unresolved base has no queue the scan can claim, so it is counted apart.
         queues = job_data.map { |j| j[:queue] || (j[:unknown_base] ? "unknown" : "default") }
-                         .tally.sort_by { |_, c| -c }
+                         .tally.sort_by.with_index { |(_, c), i| [ -c, i ] }
         if queues.any?
           queue_str = queues.map { |q, c| "#{q}(#{c})" }.join(", ")
           lines << "**Queues:** #{queue_str}"
@@ -549,9 +549,10 @@ module RailsAiContext
         body = perform && Introspectors::ActionResolver.body_of(source, perform)
         return [] unless body
 
-        body[:code].lines.map(&:strip).select { |line|
+        guards = body[:code].lines.map(&:strip).select { |line|
           line.match?(/\Areturn\s+(if|unless)\b/) || (line.match?(/\Areturn\b/) && line.length < 120)
         }.first(10)
+        RailsAiContext::Redaction.redact_source_lines(guards)
       end
 
       private_class_method def self.extract_broadcasts(source)

data/lib/rails_ai_context/tools/get_mailers.rb

@@ -29,8 +29,8 @@ module RailsAiContext
 
       guide_row(
         order: 41,
-        mcp: "rails_get_mailers(mailer:\"UserMailer\")",
-        cli_args: "mailer=UserMailer",
+        mcp: "rails_get_mailers(mailer:\"X\")",
+        cli_args: "mailer=X",
         summary: "Mailer classes with delivery actions and delivery method, mailboxes and their routing"
       )
 
@@ -76,7 +76,7 @@ module RailsAiContext
           elsif page[:total].zero?
             # An empty page past the end is not an app without mailers, and the
             # hint below already says where the end is.
-            lines << "_No mailers found#{" matching '#{mailer}'" if mailer}._"
+            lines << "_No mailers found#{" matching '#{echo_input(mailer)}'" if mailer}._"
           end
 
           lines.concat(mailbox_lines(Payload.section(cached_context, :action_mailbox))) if mailer.nil? && page[:offset].zero?

data/lib/rails_ai_context/tools/get_model_details.rb

@@ -44,7 +44,7 @@ module RailsAiContext
             data = models[key]
             unless data
               reason = RailsAiContext::AppKind.without_active_record(rails_app.root)
-              return empty_response("No Active Record model named #{model}: #{reason}.") if reason && models.empty?
+              return empty_response("No Active Record model named #{echo_input(model)}: #{reason}.") if reason && models.empty?
 
               return not_found_response("Model", model, models.keys.sort,
                 recovery_tool: "Call rails_get_model_details(detail:\"summary\") to see all models")
@@ -96,8 +96,9 @@ module RailsAiContext
                 next
               end
               assocs = Serializers::SectionFacts.associations_list(data).join(", ")
+              note = Serializers::SectionFacts.table_note(Payload.section(cached_context, :schema), data)
               line = "- **#{name}**"
-              line += " (table: #{data[:table_name]})" if data[:table_name]
+              line += note ? " (table #{note})" : (" (table: #{data[:table_name]})" if data[:table_name]).to_s
               line += " - #{assocs}" unless assocs.empty?
               lines << line
             end
@@ -155,15 +156,20 @@ module RailsAiContext
       private_class_method def self.format_model(name, data)
         # Static-tier entries already carry [STATIC]; a runtime entry with a
         # resolved table is reflection-confirmed, hence [VERIFIED].
+        note = Serializers::SectionFacts.table_note(Payload.section(cached_context, :schema), data)
         header_tag = if data[:confidence]
           " #{data[:confidence]}"
-        elsif data[:table_name] && !RailsAiContext.static_tier?
+        elsif data[:table_name] && !note && !RailsAiContext.static_tier?
           " #{Confidence::VERIFIED}"
         else
           ""
         end
         lines = [ "# #{name}#{header_tag}", "" ]
-        lines << "**Table:** `#{data[:table_name]}`" if data[:table_name]
+        if note
+          lines << "**Table:** #{note}"
+        elsif data[:table_name]
+          lines << "**Table:** `#{data[:table_name]}`"
+        end
         if (database = data[:database])
           lines << "**Database:** `#{database[:connects_to]}`#{" (only #{database[:condition]})" if database[:condition]}" \
                    "#{", inherited from `#{database[:declared_in]}`" if database[:declared_in]}"
@@ -174,6 +180,10 @@ module RailsAiContext
         # all, so this stands outside that section.
         bases_unread = data[:bases_unread]
         lines << unread_bases_line(bases_unread) if bases_unread&.any?
+        if (patches = data[:patches_unread])&.any?
+          lines << "#{Confidence::UNAVAILABLE} #{count_phrase(patches.size, "patch module")} not read, so what " \
+                   "#{patches.one? ? "it adds" : "they add"} to #{name} is missing here: #{patches.join(', ')}"
+        end
 
         # File structure - compact one-line format
         structure = extract_model_structure(name)
@@ -220,11 +230,16 @@ module RailsAiContext
         # Mongoid documents have no AR table/columns - render declared fields
         # and embedded relations directly from the source-parsed macros instead.
         if data[:mongoid]
+          # The collection is where the documents live, as the table is for a
+          # record; an embedded document has none of its own.
+          lines.insert(2, "**Collection:** `#{data[:collection]}`") if data[:collection]
+          lines.insert(2, "**Embedded in:** `#{data[:embedded_in]}` (no collection of its own)") if data[:embedded_in]
           if data[:fields]&.any?
             lines << "" << "## Fields"
             data[:fields].each do |f|
               type_str = f[:type] ? ": #{f[:type]}" : ""
-              lines << "- `#{f[:name]}`#{type_str}#{", default: #{f[:default]}" if f.key?(:default)}"
+              from = f[:implicit] ? " _(#{f[:implicit]})_" : ""
+              lines << "- `#{f[:name]}`#{type_str}#{", default: #{f[:default]}" if f.key?(:default)}#{from}"
             end
           end
 
@@ -282,7 +297,7 @@ module RailsAiContext
           data[:validations].each do |v|
             next if v[:implicit] && (v[:attributes] & written).any?
 
-            dedup_key = [ v[:kind].to_s, v[:attributes].sort, v[:options] ]
+            dedup_key = [ v[:kind].to_s, v[:validator], v[:attributes].sort, v[:options] ]
             next if seen_validations.include?(dedup_key)
             seen_validations << dedup_key
             attrs = v[:attributes].join(", ")
@@ -563,8 +578,10 @@ module RailsAiContext
         # Cross-reference hints - guide AI to related tools
         hints = []
         hints << "`rails_get_schema(table:\"#{data[:table_name]}\")` for columns/indexes" if data[:table_name]
-        controller_name = "#{name.pluralize}Controller"
-        hints << "`rails_get_controllers(controller:\"#{controller_name}\")` for actions" if name.match?(/\A[A-Z][a-z]/)
+        # Only a controller the app has: the conventional name is a guess, and
+        # a hint naming a class that does not exist sends the reader nowhere.
+        controller_name = Payload.controller_for_route_key(cached_context, name.underscore.pluralize)&.first
+        hints << "`rails_get_controllers(controller:\"#{controller_name}\")` for actions" if controller_name
         hints << "`rails_analyze_feature(feature:\"#{name}\")` for full-stack view"
         lines << "" << "_Next: #{hints.join(' | ')}_"
 
@@ -579,9 +596,12 @@ module RailsAiContext
       end
 
       # A carried path can name a gem rather than the app, and joining that to
-      # the app root opens nothing. One reader answers both shapes.
+      # the app root opens nothing. One reader answers both shapes. A file a
+      # symlink carries out of the app is not read.
       private_class_method def self.resolved_model_path(model_name)
-        RailsAiContext::PortablePath.resolve(relative_model_path(model_name), rails_app.root.to_s)
+        root = rails_app.root.to_s
+        path = RailsAiContext::PortablePath.resolve(relative_model_path(model_name), root)
+        path unless path && RailsAiContext::PathResolver.linked_out?(path, root)
       end
 
       # The macro's options are nested under an :options key. Printing that

data/lib/rails_ai_context/tools/get_partial_interface.rb

@@ -46,8 +46,8 @@ module RailsAiContext
         # decides whether the partial exists.
         guard = RailsAiContext::SafePath.locate(partial, under: views_dir, root: root)
         case guard.refusal
-        when :traversal then return error_response("Path not allowed: #{partial}")
-        when :sensitive then return error_response("Path not allowed: #{partial} (sensitive file)")
+        when :traversal then return error_response("Path not allowed: #{echo_input(partial)}")
+        when :sensitive then return error_response("Path not allowed: #{echo_input(partial)} (sensitive file)")
         end
 
         if view_dirs.empty?
@@ -70,6 +70,12 @@ module RailsAiContext
 
         located = view_dirs.lazy.filter_map { |dir| resolve_partial_path(dir, partial) }.first
 
+        # The file the name resolves to, refused on policy: a link out of the app.
+        case located&.refusal
+        when :traversal, :outside then return error_response("Path not allowed: #{echo_input(partial)}")
+        when :sensitive then return error_response("Path not allowed: #{echo_input(partial)} (sensitive file)")
+        end
+
         unless located
           available = view_dirs.flat_map { |dir| find_available_partials(dir, root) }.uniq.sort.first(30)
           return not_found_response("Partial", partial, available,
@@ -92,14 +98,24 @@ module RailsAiContext
         # The resolved file, not the caller's spelling: a bare name has no
         # directory for a render site to be matched against.
         prefixed = prefix_partial_paths?(root)
-        render_sites = view_dirs.flat_map { |dir| find_render_sites(dir, partial_name, root, prefixed) }
+        render_sites = view_dirs.flat_map { |dir| find_render_sites(dir, partial_name, root, prefixed) } +
+                       code_render_sites(root, canonical_name(partial_name))
+        # `_post.html.erb` and `_post.json.jbuilder` share a name but not their
+        # callers: each renders only where its format is the one looked up.
+        partial_format = template_format(file_path)
+        render_sites = render_sites.select { |site| renders_format?(site, partial_format) }
         method_calls = {}
 
         # Primary: locals from render call sites (ground truth)
         render_locals = render_sites.flat_map { |rs| rs[:locals] || [] }.uniq
 
         # Secondary: local_assigns checks + defined? guards in partial source
-        source_locals = extract_local_variable_references(source, Introspectors::HelperNames.for(root))
+        helpers = Introspectors::HelperNames.for(root)
+        source_locals = if file_path.end_with?(".jbuilder")
+          jbuilder_locals(source, helpers)
+        else
+          extract_local_variable_references(source, helpers)
+        end
 
         # Combine: render-site locals first, then source-detected locals
         # Filter out noise: single chars, capitalized words, known helpers
@@ -170,7 +186,7 @@ module RailsAiContext
             next unless full && site[:snippet]
 
             lines << "  ```erb"
-            lines << "  #{site[:snippet].strip}"
+            lines << "  #{RailsAiContext::Redaction.redact_source(site[:snippet].strip, path: site[:file])}"
             lines << "  ```"
           end
           if render_sites.size > cap
@@ -183,7 +199,7 @@ module RailsAiContext
         if full
           lines << "" << "## Source"
           lines << "```erb"
-          lines << source
+          lines << RailsAiContext::Redaction.redact_source(source, path: relative_path)
           lines << "```"
         else
           lines << ""
@@ -223,8 +239,9 @@ module RailsAiContext
 
         return nil unless found
 
+        # A refused file comes back with its refusal, so the caller says so rather than call it missing.
         located = RailsAiContext::SafePath.locate(found.delete_prefix(views_dir + File::SEPARATOR), under: views_dir, root: rails_app.root.to_s)
-        located.ok? || located.refusal == :too_large ? located : nil
+        located.refusal == :missing ? nil : located
       end
 
       # A view file's name as the app renders it: its path under the innermost
@@ -309,10 +326,14 @@ module RailsAiContext
           code = match[0].strip
           next if code.start_with?("#")
 
-          # 1. Standalone ERB output: <%= local_name %> or <%= local_name.method %>
-          if (m = code.match(/\A\s*([a-z_]\w*)\s*(?:\z|\.|\()/))
+          # 1. Standalone ERB output: <%= local_name %> or <%= local_name.method %>.
+          # A name called with parentheses is a method, and one ending in
+          # _path or _url a route helper: `dom_id(notification)` and
+          # `mark_read_notification_path(notification)` were listed as locals.
+          if (m = code.match(/\A\s*([a-z_]\w*)\s*(?:\z|\.)/))
             name = m[1]
-            locals << name unless known_non_locals.include?(name) || block_params.include?(name) || helpers.include?(name)
+            locals << name unless known_non_locals.include?(name) || block_params.include?(name) ||
+                                  helpers.include?(name) || route_helper?(name)
           end
 
           # 2. defined?(local) guard pattern
@@ -334,6 +355,200 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [], label: "extract_local_variable_references")
       end
 
+      # Every template a render site can sit in, jbuilder's Ruby included.
+      SITE_GLOB = "**/*.{erb,haml,slim,jbuilder}"
+
+      # Whether a site looks a partial of this format up: in the formats the
+      # call names, else those its place gives it (nil for any).
+      private_class_method def self.renders_format?(site, format)
+        return true unless format
+
+        formats = site.key?(:formats) ? site[:formats] : template_lookup(site[:file])
+        formats.nil? || formats.include?(format)
+      end
+
+      # A template looks in its own format: a json.jbuilder in json, an
+      # html.erb in html, and one whose name gives none in any. A
+      # turbo_stream template looks in html too (Turbo's request accepts
+      # html), as a js one does (Rails' html fallback for js).
+      private_class_method def self.template_lookup(file)
+        own = template_format(file) or return nil
+        %w[turbo_stream js].include?(own) ? [ own, "html" ] : [ own ]
+      end
+
+      # `render partial: "posts/post", formats: [:json]`: the formats a call
+      # names, which Rails looks the partial up in whatever the request asked.
+      # Action View reads `options[:formats]` alone, from the hash it renders
+      # with: the one holding `partial:`, or json.partial!'s keywords. So a
+      # `format:` is a local, as is any key inside `locals: {}`, and in
+      # `render "shared/date", date: d, format: :short` every key is one.
+      FORMATS_OPTION = /(?<![\w:])(?:formats:|:formats\s*=>)\s*(?:%[iIwW])?(\[[^\]]*\]|:\w+|["']\w+["'])/
+
+      # The formats the options beside offset `at` name: those of the
+      # innermost bracket group holding it, or of the whole call, read with
+      # each hash and call nested there blanked. nil for no offset, which a
+      # call that names its partial first has.
+      private_class_method def self.named_formats(call, at)
+        return nil unless at
+
+        level = +""
+        RailsAiContext::Brackets.each_top_level(call, comments: :ruby) do |piece, kind|
+          from = level.length
+          return named_formats(piece[1...-1], at - from - 1) if kind == :group && at > from && at < from + piece.length - 1
+
+          nested = kind == :comment || (kind == :group && !piece.start_with?("["))
+          level << (nested ? " " * piece.length : piece)
+        end
+        level[FORMATS_OPTION, 1]&.scan(/\w+/)
+      end
+
+      # Where a render names the partial as its `partial:` option, or nil
+      # where it names it first, as the shorthand does.
+      private_class_method def self.partial_key_at(line, name)
+        line =~ /(?:\bpartial:|:partial\s*=>)\s*(["'])#{Regexp.escape(name)}\1/
+      end
+
+      # The formats a call in Ruby renders its partial in when it names none.
+      # A Turbo Stream builder renders html, and so do a broadcast and
+      # ApplicationController.render outside a request. In a controller or a
+      # helper the request decides, html or json alike, unless the call sits
+      # in a `format.json { }` block of a respond_to.
+      private_class_method def self.code_site_formats(call, relative, line, format_blocks)
+        return [ "html" ] if call.match?(/\bturbo_stream\.\w+/)
+
+        block = format_blocks.select { |from, to, _| from <= line && line <= to }.max_by(&:first)
+        return (block.last == "any" ? nil : [ block.last ]) if block
+        return nil if relative.match?(%r{(?:\A|/)app/(?:controllers|helpers)/})
+
+        [ "html" ]
+      end
+
+      # [first line, last line, format] of each `format.json { }` block a
+      # respond_to holds, whatever its block names the collector.
+      private_class_method def self.format_blocks(content)
+        blocks = []
+        visit = lambda do |node|
+          if node.is_a?(Prism::CallNode) && node.name == :respond_to && node.block.is_a?(Prism::BlockNode)
+            param = node.block.parameters&.parameters&.requireds&.first
+            collector = param.respond_to?(:name) ? param.name : nil
+            collect = lambda do |inner|
+              if inner.is_a?(Prism::CallNode) && inner.block && inner.receiver.is_a?(Prism::LocalVariableReadNode) && inner.receiver.name == collector
+                blocks << [ inner.block.location.start_line, inner.block.location.end_line, inner.name.to_s ]
+              end
+              inner.compact_child_nodes.each(&collect)
+            end
+            collect.call(node.block)
+          end
+          node.compact_child_nodes.each(&visit)
+        end
+        visit.call(RailsAiContext::AstCache.parse_string(content).value)
+        blocks
+      rescue => e
+        RailsAiContext.debug_fail(e, [], label: "format_blocks")
+      end
+
+      # A template's format as its name gives it; jbuilder's handler writes
+      # json, its default format, when the name gives none.
+      private_class_method def self.template_format(path)
+        RailsAiContext::ViewFile.format_of(path) || ("json" if path.end_with?(".jbuilder"))
+      end
+
+      # "shared/_status_badge.html.erb" as a render call names it: "shared/status_badge".
+      private_class_method def self.canonical_name(partial_name)
+        parts = partial_name.split("/")
+        (parts[0...-1] + [ parts.last.delete_prefix("_").sub(/\..*\z/, "") ]).join("/")
+      end
+
+      private_class_method def self.route_helper?(name)
+        name.match?(/_(?:path|url)\z/)
+      end
+
+      # Names Ruby cannot tell from a method call at parse time that a jbuilder
+      # template reads without defining them itself.
+      JBUILDER_NON_LOCALS = %w[json local_assigns params request controller current_page? render cache!].to_set.freeze
+
+      # A jbuilder partial is Ruby throughout, so the ERB tag scan found none
+      # of its locals: `invoice` in api/v1/invoices/_invoice.json.jbuilder.
+      # A local reads as a bare name the file never assigns, which Prism marks
+      # as a variable call; a helper or a route helper is not one.
+      private_class_method def self.jbuilder_locals(source, helpers)
+        names = Set.new
+        visit = lambda do |node|
+          names << node.name.to_s if node.is_a?(Prism::CallNode) && node.variable_call?
+          node.compact_child_nodes.each(&visit)
+        end
+        visit.call(RailsAiContext::AstCache.parse_string(source).value)
+        names.reject { |name| JBUILDER_NON_LOCALS.include?(name) || helpers.include?(name) || route_helper?(name) }.sort
+      rescue => e
+        RailsAiContext.debug_fail(e, [], label: "jbuilder_locals")
+      end
+
+      # Where a partial is named outside a render call: turbo_stream.prepend
+      # in a .turbo_stream.erb, broadcast_prepend_to in a model, json.partial!
+      # and json.array! in jbuilder. Ruby code outside the views names a
+      # partial by its full path, since it has no view directory of its own.
+      CODE_DIRS = %w[app/models app/controllers app/jobs app/channels app/helpers].freeze
+      # The keywords Turbo and jbuilder take beside a partial, which are not its locals.
+      PARTIAL_CALL_KEYWORDS = %w[target targets action attributes method html content renderable request_id as].freeze
+
+      private_class_method def self.partial_arg_sites(content, relative, names, skip_spans: [], code: false)
+        lines = content.lines
+        sites = []
+        blocks = nil
+        content.to_enum(:scan, Introspectors::ViewTemplateIntrospector::PARTIAL_ARG).each do
+          match = Regexp.last_match
+          at = match.begin(0)
+          next unless names.include?(match[2])
+          next if skip_spans.any? { |from, to| at >= from && at < to }
+
+          # The line the call starts on, which a trailing comma carries onto this one.
+          start = content[0...at].count("\n")
+          start -= 1 while start.positive? && lines[start - 1].rstrip.end_with?(",")
+          call = call_lines(lines, start)
+          site = { file: relative, line: start + 1, locals: partial_call_locals(call), snippet: call.squish }
+          # The name's own offset in the call: the options it is rendered
+          # with sit beside it, inside json.partial!'s parentheses too.
+          named = named_formats(call, match.begin(1) - lines.first(start).sum(&:length))
+          if code
+            site[:formats] = named || code_site_formats(call, relative, start + 1, blocks ||= format_blocks(content))
+          elsif named
+            site[:formats] = named
+          end
+          sites << site
+        end
+        sites
+      end
+
+      # The line a call starts on and every line a trailing comma carries it onto.
+      private_class_method def self.call_lines(lines, index)
+        taken = []
+        lines[index..].each do |line|
+          taken << line
+          break unless line.split("%>", 2).first.rstrip.end_with?(",")
+        end
+        taken.join.split("%>", 2).first
+      end
+
+      # The locals a call hands the partial: its `locals:` hash, the name
+      # `as:` gives each record, or json.partial!'s own keywords.
+      private_class_method def self.partial_call_locals(call)
+        named = call[/\bas:\s*:(\w+)/, 1]
+        (extract_locals_from_render(call) - PARTIAL_CALL_KEYWORDS + [ named ]).compact.uniq
+      end
+
+      private_class_method def self.code_render_sites(root, canonical)
+        CODE_DIRS.flat_map { |kind| RailsAiContext::PathResolver.dirs_for(root, kind) }.uniq.flat_map do |dir|
+          RailsAiContext::FileWalk.glob(dir, "**/*.rb", root: root).flat_map do |path|
+            content = safe_read(path)
+            next [] unless content&.include?(canonical)
+
+            partial_arg_sites(content, RailsAiContext::PortablePath.relativize(path, root), [ canonical ], code: true)
+          end
+        end
+      rescue => e
+        RailsAiContext.debug_fail(e, [], label: "code_render_sites")
+      end
+
       # Find all views that render this partial and extract the locals they pass.
       private_class_method def self.find_render_sites(views_dir, partial, root, prefixed)
         sites = []
@@ -359,7 +574,7 @@ module RailsAiContext
 
         object_paths = {}
 
-        view_files = RailsAiContext::ViewFile.glob(root, views_dir, RailsAiContext::ViewFile::MARKUP_GLOB)
+        view_files = RailsAiContext::ViewFile.glob(root, views_dir, SITE_GLOB)
 
         view_files.each do |file|
           content = safe_read(file)
@@ -371,8 +586,10 @@ module RailsAiContext
           # Per call, not per line: `render(` and a call split over lines are
           # one call whose arguments the line alone does not hold.
           covered = 0
+          spans = []
           Introspectors::ViewTemplateIntrospector.render_calls(content).each do |at, args|
             args = args.split("%>", 2).first
+            spans << [ at, at + args.length ]
             # A render inside another's arguments is already part of that call's site.
             next if at < covered
 
@@ -384,25 +601,22 @@ module RailsAiContext
 
             matched_line = false
             search_patterns.each do |search_name|
-              # Match render "partial_name" or render partial: "partial_name"
-              # Allow content before search_name (e.g. "shared/status_badge" matches "status_badge")
-              next unless line.match?(/render\s.*["'][^"']*#{Regexp.escape(search_name)}["']/)
+              # Match render "partial_name" or render partial: "partial_name",
+              # the name whole: "comments/form" is another directory's form.
+              next unless line.match?(/render\s.*["']#{Regexp.escape(search_name)}["']/)
 
-              # For short basename matches, verify directory context
+              # A bare name reaches the partial only from its own directory.
               if search_name == basename && dir_prefix.length > 0
-                # Only match if the full path is referenced, or the render is in the same directory
                 file_dir = File.dirname(file).sub("#{views_dir}/", "")
-                next unless line.include?(dir_prefix) || file_dir == dir_prefix
+                next unless file_dir == dir_prefix
               end
 
               locals_passed = extract_locals_from_render(line)
 
-              sites << {
-                file: relative,
-                line: line_num,
-                locals: locals_passed,
-                snippet: snippet
-              }
+              site = { file: relative, line: line_num, locals: locals_passed, snippet: snippet }
+              named = named_formats(line, partial_key_at(line, search_name))
+              site[:formats] = named if named
+              sites << site
               matched_line = true
               break # one match per call is enough
             end
@@ -417,6 +631,11 @@ module RailsAiContext
 
             sites << { file: relative, line: line_num, locals: [], snippet: snippet }
           end
+
+          # A bare name reaches the partial only from its own directory.
+          file_dir = File.dirname(file).sub("#{views_dir}/", "")
+          names = dir_prefix.empty? || file_dir == dir_prefix ? search_patterns : [ canonical ]
+          sites.concat(partial_arg_sites(content, relative, names, skip_spans: spans))
         end
 
         sites

data/lib/rails_ai_context/tools/get_routes.rb

@@ -25,7 +25,9 @@ module RailsAiContext
           },
           app_only: {
             type: "boolean",
-            description: "Filter out internal Rails routes (Active Storage, Action Mailbox, Conductor, etc.). Default: true."
+            description: "Leave out the routes Rails' engines and gems draw on their own (Active Storage, Action Mailbox and its conductor, " \
+                         "Turbo Native navigation, Rails' info and mailer-preview pages). Routes the app's route files declare stay, " \
+                         "devise_for's and the health check's included. A controller filter searches every route. Default: true."
           }
         }
       )
@@ -41,16 +43,25 @@ module RailsAiContext
 
       # The filters this controller actually runs, read the way every other
       # surface reads them, so a skipped one is never named here. The cut is
-      # stated rather than silent.
+      # stated rather than silent. A filter that runs on some actions only says
+      # which, so a route whose action skips it is not read as guarded by it.
       def self.filter_hint(ctrl_class, ctx)
         chain = RailsAiContext::ActionFilters.for_controller(ctx, ctrl_class, root: rails_app&.root&.to_s)
-        names = chain[:chain].map { |f| f[:name] }
+        names = chain[:chain].map { |f| "#{f[:name]}#{filter_scope(f)}" }
         return nil if names.empty?
 
         rest = names.size - HINTED_FILTERS
         "#{names.first(HINTED_FILTERS).join(', ')}#{rest.positive? ? " (+#{rest} more)" : ''}"
       end
 
+      def self.filter_scope(filter)
+        scope = +""
+        scope << " (only: #{Array(filter[:only]).join(', ')})" if Array(filter[:only]).any?
+        scope << " (except: #{Array(filter[:except]).join(', ')})" if Array(filter[:except]).any?
+        scope + RailsAiContext::Serializers::SectionFacts.skip_condition_tail(filter)
+      end
+      private_class_method :filter_scope
+
       guide_row(
         order: 8,
         mcp: "rails_get_routes(controller:\"X\")",
@@ -110,16 +121,21 @@ module RailsAiContext
         elsif group[:mount_computed] then " at a path the routes compute"
         else " (not mounted by the app's routes)"
         end
-        at += " (also #{group[:also_mounted_at].map { |path| "`#{path}`" }.join(', ')})" if group[:also_mounted_at]
+        at += " (also #{also_mounted_at(group)})" if group[:also_mounted_at]
         at
       end
 
+      private_class_method def self.also_mounted_at(group)
+        group[:also_mounted_at].map { |path| "`#{path}`" }.join(", ")
+      end
+
       # The routes a controller filter matches in the engines' tables, one
       # group per controller labelled with its engine, listed like the app's.
       private_class_method def self.engine_controller_groups(engine_routes, needles)
         Array(engine_routes).each_with_object({}) do |group, found|
           matches = Array(group[:routes]).select { |r| needles.any? { |n| path_segments_match?(r[:controller].to_s, n, tail: true) } }
           where = group[:mount] || group[:mount_computed] ? "" : ", not mounted by the app's routes"
+          where += ", also mounted at #{also_mounted_at(group)}" if group[:also_mounted_at]
           matches.group_by { |r| r[:controller] }.each do |ctrl, rows|
             found["#{ctrl} (in #{group[:engine]}'s table#{where})"] = rows
           end
@@ -143,8 +159,10 @@ module RailsAiContext
 
           # Filter out internal Rails routes by default, remembering how many
           # were dropped so headers can say the count is app-only, not the total.
+          # A controller filter names the routes it wants, so it searches the
+          # whole table: `controller:"active_storage/blobs"` is asked for by name.
           excluded_framework_count = 0
-          if app_only
+          if app_only && controller.nil?
             framework_ctrls = by_controller.select { |k, _| framework_controller?(k) }
             excluded_framework_count = framework_ctrls.values.sum { |actions| RailsAiContext::RouteCoverage.dedupe_put_patch_routes(actions).size }
             by_controller = by_controller.reject { |k, _| framework_controller?(k) }
@@ -164,9 +182,12 @@ module RailsAiContext
             filtered = filtered.merge(engine_controller_groups(routes[:engine_routes], needles))
             if filtered.empty?
               # The whole controller list would bury the sentence saying the name matched none.
-              known = by_controller.keys.sort
-              return empty_response("No routes for '#{controller}'. Controllers: " \
-                                    "#{known.first(20).join(', ')}#{" ... and #{known.size - 20} more" if known.size > 20}")
+              known = by_controller.keys.reject { |k| framework_controller?(k) }.sort
+              # Booted, a dynamic route has no controller, so it cannot be the one asked for.
+              unexpanded = routes[:confidence] == RailsAiContext::Confidence::STATIC ? routes[:dynamic_routes].to_i : 0
+              unread = ". #{count_phrase(unexpanded, "dynamic construct")} not expanded, so a route for this controller may be missing from this table." if unexpanded.positive?
+              return empty_response("No routes for '#{echo_input(controller)}'. Controllers: " \
+                                    "#{known.first(20).join(', ')}#{" ... and #{known.size - 20} more" if known.size > 20}#{unread}")
             end
             by_controller = filtered
           end