rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/tools/get_partial_interface.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 module RailsAiContext
   module Tools
     class GetPartialInterface < BaseTool
@@ -49,7 +51,7 @@ module RailsAiContext
         end
 
         if view_dirs.empty?
-          note = api_only_note("app/views")
+          note = api_only_note("app/views", dir: "app/views")
           return text_response(note) if note
 
           return text_response("No app/views/ directory found.")
@@ -71,7 +73,7 @@ module RailsAiContext
         unless located
           available = view_dirs.flat_map { |dir| find_available_partials(dir, root) }.uniq.sort.first(30)
           return not_found_response("Partial", partial, available,
-            recovery_tool: "Call rails_get_view(detail:\"summary\") to see all views and partials")
+            recovery_tool: "Call rails_get_view(detail:\"summary\") to see all views and partials", note: static_engine_views_note)
         end
 
         file_path = located.realpath
@@ -83,11 +85,14 @@ module RailsAiContext
         return text_response("Could not read partial file.") unless source
 
         relative_path = located.relative
-        partial_name = relative_path.sub(%r{\A.*app/views/}, "")
+        partial_name = view_relative(File.expand_path(relative_path, root), view_dirs)
 
         # Parse the partial's interface
         magic_locals = extract_magic_comment_locals(source)
-        render_sites = view_dirs.flat_map { |dir| find_render_sites(dir, partial, root) }
+        # 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) }
         method_calls = {}
 
         # Primary: locals from render call sites (ground truth)
@@ -98,8 +103,8 @@ module RailsAiContext
 
         # Combine: render-site locals first, then source-detected locals
         # Filter out noise: single chars, capitalized words, known helpers
-        all_locals = (magic_locals + render_locals + source_locals).uniq
-          .reject { |l| l.length <= 1 || l.match?(/\A[A-Z]/) || l.match?(/\Arender_/) }
+        all_locals = (Array(magic_locals) + render_locals + source_locals).uniq
+          .reject { |l| l.length <= 1 || l.match?(/\A[A-Z*]/) || l.match?(/\Arender_/) }
           .sort
 
         # Extract method calls only for confirmed locals
@@ -118,7 +123,7 @@ module RailsAiContext
         lines = [ "# Partial: #{partial_name}", "" ]
 
         if all_locals.any?
-          magic_note = magic_locals.any? ? " (#{magic_locals.size} declared via magic comment)" : ""
+          magic_note = magic_locals&.any? ? " (#{magic_locals.size} declared via magic comment)" : ""
           lines << "**Locals:** #{all_locals.join(', ')}#{magic_note}"
         else
           lines << "**Locals:** none detected"
@@ -135,8 +140,9 @@ module RailsAiContext
         lines = [ "# Partial: #{partial_name}", "" ]
         lines << "**File:** `#{relative_path}` (#{count_phrase(source.lines.size, "line")})"
 
-        if magic_locals.any?
-          lines << "**Declared locals** (Rails 7.1+ magic comment): #{magic_locals.join(', ')}"
+        if magic_locals
+          declared = magic_locals.any? ? magic_locals.join(", ") : "none, so passing any local raises"
+          lines << "**Declared locals** (Rails 7.1+ magic comment): #{declared}"
         end
 
         if all_locals.any?
@@ -151,7 +157,7 @@ module RailsAiContext
               lines << "- **#{local}**"
             end
           end
-        elsif !full
+        elsif !full && !magic_locals
           lines << "" << "_No local variables detected in this partial._"
         end
 
@@ -203,9 +209,11 @@ module RailsAiContext
         # A fixed extension list refused `.text.erb`, which the Available
         # list built by globbing had just offered. Rails names a partial by
         # its directory and basename, whatever format and handler follow.
+        # The plain file before a locale or variant one: Rails renders it for a request that asks for neither.
+        plain_first = ->(paths) { paths.sort_by { |path| [ view_alternate_of(path) ? 1 : 0, path ] } }
         candidates = [
-          *Dir.glob(File.join(views_dir, *dir_parts, "#{prefixed_basename}.*")).sort,
-          *Dir.glob(File.join(views_dir, *dir_parts, "#{unprefixed_basename}.*")).sort,
+          *plain_first.call(Dir.glob(File.join(views_dir, *dir_parts, "#{prefixed_basename}.*"))),
+          *plain_first.call(Dir.glob(File.join(views_dir, *dir_parts, "#{unprefixed_basename}.*"))),
           File.join(views_dir, partial)
         ]
 
@@ -219,10 +227,10 @@ module RailsAiContext
         located.ok? || located.refusal == :too_large ? located : nil
       end
 
-      # A view file's name as the app renders it: its path under whichever
-      # views root holds it.
+      # A view file's name as the app renders it: its path under the innermost
+      # views root that holds it.
       private_class_method def self.view_relative(path, view_dirs)
-        dir = view_dirs.find { |d| path.start_with?(d + File::SEPARATOR) }
+        dir = RailsAiContext::ViewFile.root_for(path, view_dirs)
         dir ? path.delete_prefix(dir + File::SEPARATOR) : path
       end
 
@@ -233,26 +241,29 @@ module RailsAiContext
         return [] if name.include?("/")
 
         name = "_#{name}" unless name.start_with?("_")
-        Dir.glob(File.join(views_dir, "**", "#{name}.*")).sort.select { |c| File.file?(c) }
+        RailsAiContext::ViewFile.glob(rails_app.root.to_s, views_dir, File.join("**", "#{name}.*")).select { |c| File.file?(c) }
       end
 
-      # Extract locals declared via Rails 7.1+ magic comment: <%# locals: (name:, title: "default") %>
+      # ActionView::Template::STRICT_LOCALS_REGEX as of Rails 8.0, held here so
+      # the static tier reads the comment the same way.
+      STRICT_LOCALS = /\#\s+locals:\s+\((.*?)\)(?=\s*-?%>|\s*$)/m
+
+      # The names a strict locals comment declares; nil without one, [] for
+      # `()`, which allows no locals at all.
       private_class_method def self.extract_magic_comment_locals(source)
-        locals = []
+        list = source[STRICT_LOCALS, 1]
+        return nil unless list
 
-        source.each_line do |line|
-          if (match = line.match(/<%#\s*locals:\s*\(([^)]+)\)\s*%>/))
-            params_str = match[1]
-            # Parse Ruby-style keyword params: name:, title: "default", count: 0
-            params_str.scan(/([\w]+):/) do |param_match|
-              locals << param_match[0]
-            end
-          end
-        end
+        result = RailsAiContext::AstCache.parse_string("def _(#{list}); end")
+        return list.scan(/(\w+):/).flatten.uniq unless result.success?
 
-        locals.uniq
+        params = result.value.statements.body.first.parameters
+        return [] unless params
+
+        rest = params.keyword_rest
+        params.keywords.map { |p| p.name.to_s } + (rest.is_a?(Prism::KeywordRestParameterNode) ? [ "**#{rest.name}" ] : [])
       rescue => e
-        RailsAiContext.debug_fail(e, [], label: "extract_magic_comment_locals")
+        RailsAiContext.debug_fail(e, nil, label: "extract_magic_comment_locals")
       end
 
       # Extract local variable references from ERB source.
@@ -324,7 +335,7 @@ module RailsAiContext
       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)
+      private_class_method def self.find_render_sites(views_dir, partial, root, prefixed)
         sites = []
         # Build search names: the partial can be referenced multiple ways
         # Normalize: strip underscore prefix from basename and extensions
@@ -346,28 +357,15 @@ module RailsAiContext
           basename                                                  # status_badge
         ].uniq
 
-        # Implicit object/collection rendering resolves to this partial via
-        # to_partial_path: `render @post`, `render post`, `render @posts`,
-        # `render posts` all hit posts/_post. These are extremely common and
-        # carry no quoted partial name, so the explicit-string match above
-        # misses them. Only treat the partial as a conventional resource
-        # partial (posts/_post) when its directory is the pluralized basename
-        # or it is top-level, to avoid matching unrelated variables.
-        plural = basename.pluralize
-        implicit_names =
-          if dir_prefix.empty? || dir_prefix.split("/").last == plural
-            [ basename, plural ].uniq
-          else
-            []
-          end
+        object_paths = {}
 
-        view_files = Dir.glob(File.join(views_dir, RailsAiContext::ViewFile::MARKUP_GLOB)).sort
+        view_files = RailsAiContext::ViewFile.glob(root, views_dir, RailsAiContext::ViewFile::MARKUP_GLOB)
 
         view_files.each do |file|
           content = safe_read(file)
           next unless content
 
-          relative = file.sub("#{root}/", "")
+          relative = RailsAiContext::PortablePath.relativize(file, root)
 
           lines = content.lines
           # Per call, not per line: `render(` and a call split over lines are
@@ -380,7 +378,7 @@ module RailsAiContext
 
             covered = at + args.length
             line_num = content[0...at].count("\n") + 1
-            line = "render #{args.gsub(/\s+/, " ").strip}"
+            line = Introspectors::ViewTemplateIntrospector.render_line(args)
             spanned = lines[(line_num - 1)..(line_num - 1 + args.chomp.count("\n"))]
             snippet = spanned.size > 1 ? spanned.join(" ").squish : lines[line_num - 1].strip
 
@@ -411,21 +409,13 @@ module RailsAiContext
 
             next if matched_line
 
-            # Implicit object/collection render: `render @post`, `render post`,
-            # `render @posts`. The variable is a bareword or ivar (no quotes),
-            # and \b guards against prefixes like post_path / posts_controller.
-            implicit_names.each do |var|
-              next unless line.match?(/render\s+@?#{Regexp.escape(var)}\b/)
-              next if line.match?(/render\s.*["']/) # a quoted render is explicit, handled above
+            chain = line[Introspectors::ViewTemplateIntrospector::IMPLICIT_RENDER, 1]
+            next unless chain && !line.include?("partial:")
 
-              sites << {
-                file: relative,
-                line: line_num,
-                locals: [],
-                snippet: snippet
-              }
-              break
-            end
+            view_dir = File.dirname(file.delete_prefix(views_dir + File::SEPARATOR))
+            next unless implicit_partial(chain, view_dir, prefixed, root, object_paths) == canonical
+
+            sites << { file: relative, line: line_num, locals: [], snippet: snippet }
           end
         end
 
@@ -434,6 +424,55 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [], label: "find_render_sites")
       end
 
+      # The partial Rails renders for the records `chain` names from a view in
+      # view_dir, which stands in for the controller's path; nil when the
+      # model's to_partial_path or the chain cannot be read.
+      private_class_method def self.implicit_partial(chain, view_dir, prefixed, root, memo)
+        model, = Introspectors::RenderedRecord.resolve(chain, root, memo)
+        path = model && Introspectors::RenderedRecord.partial_path(model, root, memo)
+        return path unless path && prefixed
+
+        merge_prefix_into_object_path(view_dir == "." ? "" : view_dir, path)
+      end
+
+      # ActionView::AbstractRenderer#merge_prefix_into_object_path.
+      private_class_method def self.merge_prefix_into_object_path(prefix, object_path)
+        return object_path unless prefix.include?("/") && object_path.include?("/")
+
+        prefixes = []
+        object_dirs = object_path.split("/")[0..-3]
+        File.dirname(prefix).split("/").each_with_index do |dir, index|
+          break if dir == object_dirs[index]
+
+          prefixes << dir
+        end
+        (prefixes << object_path).join("/")
+      end
+
+      # Rails prefixes a record's partial with the controller namespace unless
+      # ActionView::Base.prefix_partial_path_with_controller_namespace is false.
+      PREFIX_SETTER = :prefix_partial_path_with_controller_namespace=
+
+      private_class_method def self.prefix_partial_paths?(root)
+        return ActionView::Base.prefix_partial_path_with_controller_namespace != false if booted_app? && defined?(ActionView::Base)
+
+        prefix = "#{root.to_s.chomp('/')}/"
+        files = [ "config/application.rb", "config/environments/#{rails_env_name}.rb" ] +
+          RailsAiContext::PathResolver.initializer_paths(root).map { |path| path.delete_prefix(prefix) }
+        last = nil
+        # The setter name is ActionView's own, so config.action_view, ActionView::Base and an on_load `self.` all match.
+        listener = -> { Introspectors::Listeners::MethodCallListener.new(names: [ PREFIX_SETTER ]) }
+        files.each do |relative|
+          next unless RailsAiContext::SafePath.locate(relative, under: root).ok?
+
+          walked = Introspectors::SourceIntrospector.walk(File.join(root, relative), { setting: listener })
+          walked[:setting].each { |call| last = call[:arguments].first if [ true, false ].include?(call[:arguments].first) }
+        end
+        last != false
+      rescue => e
+        RailsAiContext.debug_fail(e, true, label: "prefix_partial_paths?")
+      end
+
       # Extract local variable names from a render call line.
       private_class_method def self.extract_locals_from_render(line)
         locals = []
@@ -492,7 +531,7 @@ module RailsAiContext
 
       # Find available partials for fuzzy matching in not_found_response.
       private_class_method def self.find_available_partials(views_dir, root)
-        Dir.glob(File.join(views_dir, "**", "_*")).select { |f| File.file?(f) && RailsAiContext::ViewFile.template?(f) }.map do |f|
+        RailsAiContext::ViewFile.glob(root, views_dir, File.join("**", "_*")).select { |f| File.file?(f) && RailsAiContext::ViewFile.template?(f) }.map do |f|
           relative = f.sub("#{views_dir}/", "")
           # Strip underscore prefix and extension for display
           parts = relative.split("/")

data/lib/rails_ai_context/tools/get_routes.rb

@@ -36,12 +36,15 @@ module RailsAiContext
 
       HINTED_FILTERS = 3
 
+      GEM_DRAWN_NOTE = "_Read from source: #{RailsAiContext::RouteCoverage::GEM_DRAWN} (Active Storage, Action Mailbox, conductor) " \
+                       "are read only with the app booted, so no count here includes them._"
+
       # 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.
       def self.filter_hint(ctrl_class, ctx)
         chain = RailsAiContext::ActionFilters.for_controller(ctx, ctrl_class, root: rails_app&.root&.to_s)
-        names = (chain[:inherited] + chain[:own]).map { |f| f[:name] }
+        names = chain[:chain].map { |f| f[:name] }
         return nil if names.empty?
 
         rest = names.size - HINTED_FILTERS
@@ -57,15 +60,27 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
+      GRAPE_LIMIT = 100
+
       # A mounted app answers on a path and has no controller#action, so
       # no controller group can hold it. Counting it and then dropping it left
       # the one endpoint a reader was looking for named nowhere.
-      private_class_method def self.mounted_apps_lines(mounted_apps, engine_routes = [])
+      private_class_method def self.mounted_apps_lines(mounted_apps, engine_routes = [], grape = {}, list_grape: true)
         lines = []
         unless mounted_apps.empty?
           lines << "" << "## Mounted Apps (#{mounted_apps.size})"
           mounted_apps.each do |app|
-            lines << (app[:path] ? "- **#{app[:engine]}** at `#{app[:path]}`" : "- **#{app[:engine]}**")
+            row = app[:path] ? "- **#{app[:engine]}** at `#{app[:path]}`" : "- **#{app[:engine]}**"
+            row += " (`#{app[:condition]}`)" if app[:condition]
+            endpoints = Array(grape&.dig(app[:engine]))
+            if endpoints.any? && !list_grape
+              row += " (#{count_phrase(endpoints.size, "Grape endpoint")}, listed at detail:\"standard\")"
+            end
+            lines << row
+            if list_grape
+              endpoints.first(GRAPE_LIMIT).each { |endpoint| lines << "  - #{RailsAiContext::Introspectors::GrapeEndpoints.line(endpoint)}" }
+              lines << "  - _#{endpoints.size - GRAPE_LIMIT} more, in #{endpoints.map { |e| e[:file] }.uniq.first(3).join(', ')}_" if endpoints.size > GRAPE_LIMIT
+            end
           end
           lines << "_A mounted app's own routes are in its table, not in the count above._"
         end
@@ -160,8 +175,10 @@ module RailsAiContext
           by_controller = by_controller.transform_values { |actions| RailsAiContext::RouteCoverage.dedupe_put_patch_routes(actions) }
           filtered_total = by_controller.values.sum(&:size)
           count_label = count_phrase(filtered_total, "route")
+          from_source = routes[:confidence] == RailsAiContext::Confidence::STATIC && controller.nil?
           if excluded_framework_count > 0 && controller.nil?
             count_label += ", excluding #{count_phrase(excluded_framework_count, "framework route")}"
+            count_label += " drawn in the app's route files" if from_source
           end
           # "engine mount" named the wrong thing: a plain Rack app attached
           # with `mount` or with `match ... to:` is not an engine, and both
@@ -177,7 +194,7 @@ module RailsAiContext
           # thing an unbooted answer must not do. All three detail levels share
           # this label. Gated on `controller` because the caveat is about the
           # whole table, and a filtered answer is not that.
-          count_label += RailsAiContext::RouteCoverage.suffix(routes) if controller.nil?
+          count_label += RailsAiContext::RouteCoverage.suffix(routes, gem_drawn: false) if controller.nil?
 
           case detail
           when "summary"
@@ -219,7 +236,8 @@ module RailsAiContext
               lines << "- _#{fw_names} framework routes: #{total_fw} total_"
             end
 
-            lines.concat(mounted_apps_lines(mounted_apps, controller ? [] : routes[:engine_routes]))
+            lines.concat(mounted_apps_lines(mounted_apps, controller ? [] : routes[:engine_routes], routes[:grape_endpoints], list_grape: false))
+            lines << "" << GEM_DRAWN_NOTE if from_source
 
             if routes[:api_namespaces]&.any?
               lines << "" << "API namespaces: #{routes[:api_namespaces].join(', ')}"
@@ -274,15 +292,17 @@ module RailsAiContext
               else
                 ""
               end
-              lines << "- `#{r[:verb]}` `#{r[:path]}` → #{r[:action]}#{helper_part}#{params_part}"
+              condition = r[:condition] ? " (`#{r[:condition]}`)" : ""
+              lines << "- `#{r[:verb]}` `#{r[:path]}` → #{r[:action]}#{helper_part}#{params_part}#{condition}"
             end
 
-            lines.concat(mounted_apps_lines(mounted_apps, controller ? [] : routes[:engine_routes]))
+            lines.concat(mounted_apps_lines(mounted_apps, controller ? [] : routes[:engine_routes], routes[:grape_endpoints]))
 
             if excluded_framework_count > 0 && controller.nil?
               lines << "" << "_#{count_phrase(excluded_framework_count, "framework route")} hidden. " \
                              "Use `app_only:false` to include them._"
             end
+            lines << "" << GEM_DRAWN_NOTE if from_source
 
             lines << "" << page[:hint] unless page[:hint].empty?
             text_response(lines.join("\n"))
@@ -295,9 +315,15 @@ module RailsAiContext
             lines << "| Verb | Path | Controller#Action | Name |"
             lines << "|------|------|-------------------|------|"
             page[:items].each do |r|
-              lines << "| #{r[:verb]} | `#{r[:path]}` | #{r[:_ctrl]}##{r[:action]} | #{r[:name] || '-'} |"
+              path = "`#{r[:path]}`"
+              path += " `#{r[:constraints]}`" if r[:constraints]
+              path += " (`#{r[:condition]}`)" if r[:condition]
+              cells = [ r[:verb], path, "#{r[:_ctrl]}##{r[:action]}", r[:name] || "-" ]
+              # A merged verb is `PATCH|PUT`, and a bare pipe splits the row.
+              lines << "| #{cells.map { |cell| cell.to_s.gsub("|", "\\|") }.join(' | ')} |"
             end
-            lines.concat(mounted_apps_lines(mounted_apps, controller ? [] : routes[:engine_routes]))
+            lines.concat(mounted_apps_lines(mounted_apps, controller ? [] : routes[:engine_routes], routes[:grape_endpoints]))
+            lines << "" << GEM_DRAWN_NOTE if from_source
 
             if routes[:api_namespaces]&.any?
               lines << "" << "## API namespaces: #{routes[:api_namespaces].join(', ')}"