rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/tools/get_controllers.rb

@@ -56,18 +56,22 @@ module RailsAiContext
             key = Payload.find_controller(ctx, controller) || controller
             info = controllers[key]
             unless info
+              return text_response(application_controller_answer(ctx, controllers)) if key.casecmp?("ApplicationController")
+
               recovery = "Call rails_get_controllers(detail:\"summary\") to see all controllers"
               return not_found_response("Controller", controller, app_controller_names,
                 recovery_tool: data[:unread_engine] ? "#{unread_engine_line(data)} #{recovery}" : recovery)
             end
             return text_response("Error inspecting #{key}: #{info[:error]}") if info[:error]
 
+            chosen = resolution_note(controller, key)
             # Specific action - return source code
             if action
-              return format_action_source(key, info, action)
+              answer = format_action_source(key, info, action)
+              return chosen ? text_response("#{chosen}\n\n#{answer.content.first[:text]}") : answer
             end
 
-            return text_response(format_controller(key, info, ctx))
+            return text_response([ chosen, format_controller(key, info, ctx) ].compact.join("\n\n"))
           end
 
           app_controllers = Payload.app_controllers(ctx)
@@ -86,7 +90,7 @@ module RailsAiContext
           # Listing mode
           case detail
           when "summary"
-            lines = listing_header(page, data)
+            lines = listing_header(page, data, action)
             paginated_names.each do |name|
               info = app_controllers[name]
               action_count = info[:actions]&.size || 0
@@ -97,7 +101,7 @@ module RailsAiContext
             text_response(lines.join("\n"))
 
           when "standard"
-            lines = listing_header(page, data)
+            lines = listing_header(page, data, action)
             paginated_names.each do |name|
               info = app_controllers[name]
               lines << "- **#{name}** - #{Serializers::SectionFacts.actions_phrase(info)}"
@@ -106,7 +110,7 @@ module RailsAiContext
             text_response(lines.join("\n"))
 
           when "full"
-            lines = listing_header(page, data)
+            lines = listing_header(page, data, action)
 
             # Group sibling controllers that share the same parent and identical structure
             paginated_ctrl = app_controllers.select { |k, _| paginated_names.include?(k) }
@@ -177,8 +181,70 @@ module RailsAiContext
         )
       end
 
-      private_class_method def self.listing_header(page, data)
-        [ "# Controllers (#{page[:total]})", "", *(data[:unread_engine] ? [ unread_engine_line(data), "" ] : []) ]
+      private_class_method def self.listing_header(page, data, action = nil)
+        lines = [ "# Controllers (#{page[:total]})", "" ]
+        # An action is one controller's, and the listing used to come back as
+        # though none had been asked for.
+        lines.push("_`action:\"#{action.to_s.truncate(60)}\"` names an action of one controller, so it needs `controller:` too; this is the listing._", "") if action
+        lines.push(unread_engine_line(data), "") if data[:unread_engine]
+        lines
+      end
+
+      # The formats the controller answers: its respond_to blocks, and a
+      # template of another format beside its views, which Rails renders for
+      # that format with no respond_to at all: bazaar's products/index.json.jbuilder
+      # answers products.json, yet the line read "html, turbo_stream". A
+      # plain html-only controller gets no line.
+      private_class_method def self.formats_phrase(info, ctx, name)
+        declared = Array(info[:respond_to_formats]).map(&:to_s)
+        route_key = Payload.controller_route_key(ctx, name)
+        templates = RailsAiContext::PathResolver.view_dirs(rails_app.root.to_s).flat_map do |dir|
+          Dir.glob(File.join(dir, route_key, "*")).filter_map do |path|
+            base = File.basename(path)
+            parts = base.split(".")
+            next if base.start_with?("_") || parts.size < 3 || !File.file?(path)
+
+            [ parts[-2].sub(/\+.*\z/, ""), base ]
+          end
+        end
+        extra = templates.reject { |format, _| declared.include?(format) || format == "html" }
+                         .group_by(&:first).map { |format, found| "#{format} (#{found.map(&:last).sort.join(', ')})" }
+        shown = declared + extra
+        shown.any? ? shown.join(", ") : nil
+      rescue => e
+        RailsAiContext.debug_fail(e, nil, label: "formats_phrase")
+      end
+
+      # A bare name that matched a namespaced controller: `UsersController`
+      # answered for Admin::UsersController without a word that it had.
+      private_class_method def self.resolution_note(asked, key)
+        return nil unless key.include?("::") && !asked.to_s.include?("::") && !asked.to_s.include?("/")
+
+        "_There is no top-level `#{asked.to_s.truncate(60)}`; this is `#{key}`, the controller that name matches._"
+      end
+
+      # ApplicationController is every controller's base and no listed
+      # controller of its own, so asking for it answered "not found" though
+      # the app has one. What it declares is read off a controller that
+      # inherits it.
+      private_class_method def self.application_controller_answer(ctx, controllers)
+        root = rails_app.root.to_s
+        child = controllers.keys.sort_by { |name| [ name.count(":"), name ] }
+                           .find { |name| controllers[name].is_a?(Hash) && controllers[name][:parent_class].to_s.delete_prefix("::") == "ApplicationController" }
+        lines = [ "# ApplicationController", "" ]
+        unless child
+          lines << "The base the app's controllers inherit from. No controller read here inherits it directly, so what it declares is not read."
+          return lines.join("\n")
+        end
+
+        lines << "The base the app's controllers inherit from, not listed as a controller of its own. What it declares reaches every controller that inherits it; as #{child} reads it:"
+        filters = RailsAiContext::ActionFilters.for_controller(ctx, child, root: root)[:inherited].select { |f| f[:from].to_s == "ApplicationController" }
+        lines.push("", "## Filters", *filters.map { |f| filter_line(f) }) if filters.any?
+        settings = RailsAiContext::Introspectors::ControllerSettings.resolve(ctx, child, root: root)[:settings].select { |s| s[:from].to_s == "ApplicationController" }
+        lines.push("", "## Settings", *settings.map { |s| "- `#{s[:text]}`#{" _(through #{s[:via]})_" if s[:via]}" }) if settings.any?
+        lines.push("", "_It declares no filter or setting the controllers below it inherit._") if filters.empty? && settings.empty?
+        lines.push("", "_Next: `rails_get_controllers(controller:\"#{child}\")` for a controller that inherits it_")
+        lines.join("\n")
       end
 
       private_class_method def self.unread_engine_line(data)
@@ -222,14 +288,28 @@ module RailsAiContext
       end
 
       private_class_method def self.format_action_source(controller_name, info, action_name)
+        # An alias is the same class: its actions are read from the controller it names.
+        target = info[:alias_of] && RailsAiContext::Payload.controllers(cached_context)[info[:alias_of]]
+        return format_action_source(info[:alias_of], target, action_name) if target.is_a?(Hash) && !target[:alias_of]
+
         actions = info[:actions] || []
         # Case-insensitive action lookup for consistency with other tools
         action_name = actions.find { |a| a.to_s.downcase == action_name.to_s.downcase }&.to_s || action_name.to_s
+        carried = RailsAiContext::Payload.controller_file(cached_context, controller_name)
+        # Rails counts a public method a concern or a parent controller gives
+        # among this controller's actions, though the listing takes one only
+        # where a route names it.
+        unlisted = nil
         unless actions.map(&:to_s).include?(action_name)
-          return empty_response("Action '#{action_name}' not found in #{controller_name}. Available: #{actions.join(', ')}")
+          unlisted = RailsAiContext::Introspectors::ActionSource.unlisted_action(rails_app.root, controller_name, action_name,
+            file: carried, controllers: RailsAiContext::Payload.controllers(cached_context))
+          unless unlisted
+            return empty_response("Action '#{echo_input(action_name)}' not found in #{controller_name}. Available: #{actions.join(', ')}")
+          end
+
+          action_name = unlisted[:name]
         end
 
-        carried = RailsAiContext::Payload.controller_file(cached_context, controller_name)
         source_path = carried ? rails_app.root.join(carried) : nil
         source = source_path && safe_read(source_path.to_s)
 
@@ -237,11 +317,19 @@ module RailsAiContext
           root: rails_app.root.to_s)
 
         # Extract source code with line numbers
-        source_with_lines = source && extract_method_with_lines(source_path, action_name, source: source,
-          owner: controller_name)
+        source_with_lines = unlisted || (source && extract_method_with_lines(source_path, action_name, source: source,
+          owner: controller_name))
+        # An action from a concern or a parent controller has no def in this file.
+        source_with_lines ||= RailsAiContext::Introspectors::ActionSource.find(rails_app.root, controller_name,
+          action_name, file: carried, controllers: RailsAiContext::Payload.controllers(cached_context))
+        elsewhere = source_with_lines&.dig(:file)
+        elsewhere = nil if elsewhere == carried
 
         lines = [ "# #{controller_name}##{action_name}", "" ]
         lines << "**File:** `#{carried}`" if carried
+        parent = source_with_lines&.dig(:owner)
+        lines << "**Inherited:** from #{parent}, defined in `#{source_with_lines[:file]}`." if parent && parent != controller_name
+        lines << "**Not listed:** #{RailsAiContext::Introspectors::ActionSource::UNLISTED_NOTE}" if unlisted
 
         if applicable.values.any?(&:any?)
           lines << "" << "## Applicable Filters"
@@ -250,8 +338,9 @@ module RailsAiContext
         end
 
         if source_with_lines
-          lines << "" << "## Source (lines #{source_with_lines[:start_line]}-#{source_with_lines[:end_line]})"
-          lines << "```ruby" << source_with_lines[:code] << "```"
+          span = "lines #{source_with_lines[:start_line]}-#{source_with_lines[:end_line]}"
+          lines << "" << "## Source (#{elsewhere ? "`#{elsewhere}`, #{span}" : span})"
+          lines << "```ruby" << redacted(source_with_lines[:code], elsewhere || carried) << "```"
 
           ivars = RailsAiContext::Introspectors::ActionResolver.assigned_ivars(source_with_lines[:code])
           lines << "" << "## Instance Variables" << ivars.map { |v| "- `@#{v}`" }.join("\n") if ivars.any?
@@ -263,7 +352,7 @@ module RailsAiContext
             lines << "" << "## Private Methods Called"
             called_methods.each do |pm|
               lines << "### #{pm[:name]} (lines #{pm[:start_line]}-#{pm[:end_line]})"
-              lines << "```ruby" << pm[:code] << "```"
+              lines << "```ruby" << redacted(pm[:code], carried) << "```"
             end
           end
 
@@ -271,15 +360,15 @@ module RailsAiContext
           render_map = extract_render_map(source_with_lines[:code])
           if render_map[:redirects].any? || render_map[:renders].any?
             lines << "" << "## Render Map"
-            render_map[:redirects].each { |r| lines << "- **Redirect:** #{r}" }
-            render_map[:renders].each { |r| lines << "- **Render:** #{r}" }
+            render_map[:redirects].each { |r| lines << "- **Redirect:** #{redacted(r, carried)}" }
+            render_map[:renders].each { |r| lines << "- **Render:** #{redacted(r, carried)}" }
           end
           if render_map[:side_effects].any?
             lines << "" << "## Side Effects"
             render_map[:side_effects].each { |s| lines << "- #{s}" }
           end
         else
-          lines << "" << "_Could not extract source code. File: #{source_path || "not recorded for #{controller_name}"}_"
+          lines << "" << "_Could not extract source code. File: #{carried || "not recorded for #{controller_name}"}_"
         end
 
         # One action's answer used to carry every strong-params method in the
@@ -292,9 +381,9 @@ module RailsAiContext
           lines << "" << "## Strong Params"
           action_params.each do |sp|
             if sp.is_a?(Hash)
-              lines << "### #{sp[:name]}"
+              lines << "### #{sp[:name]}#{params_origin(sp)}"
               if sp[:unrestricted]
-                lines << "- **WARNING:** `params.permit!` - all parameters allowed"
+                lines << "- #{UNRESTRICTED}"
               else
                 lines << "- requires: `:#{sp[:requires]}`" if sp[:requires]
                 lines << "- permits: #{sp[:permits].map { |p| "`:#{p}`" }.join(', ')}" if sp[:permits]&.any?
@@ -304,13 +393,14 @@ module RailsAiContext
                 end
                 sp[:arrays]&.each { |a| lines << "- array: `#{a}: []`" }
                 sp[:hashes]&.each { |h| lines << "- hash: `#{h}: {}`" }
+                sp[:computed]&.each { |key, source| lines << "- nested, computed: `#{key}: #{source}`" }
               end
               body = extract_method_with_lines(source_path, sp[:name], source: source, owner: controller_name)
-              lines << "```ruby" << body[:code] << "```" if body
+              lines << "```ruby" << redacted(body[:code], carried) << "```" if body
             else
               body = extract_method_with_lines(source_path, sp, source: source, owner: controller_name)
               if body
-                lines << "```ruby" << body[:code] << "```"
+                lines << "```ruby" << redacted(body[:code], carried) << "```"
               else
                 lines << "- `#{sp}`"
               end
@@ -371,6 +461,12 @@ module RailsAiContext
         end
       end
 
+      UNRESTRICTED = "**WARNING:** `params.permit!` - all parameters allowed"
+
+      private_class_method def self.params_origin(entry)
+        " _(from #{entry[:from]})_" if entry[:from]
+      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)
@@ -394,32 +490,13 @@ module RailsAiContext
 
       # Extract render map from action source: redirects, renders, and side effects
       private_class_method def self.extract_render_map(code)
-        redirects = []
-        renders = []
+        redirects, renders = render_and_redirect_calls(code)
         side_effects = []
         enqueues = Introspectors::SourceCalls.enqueue_calls(code, enqueue_helpers).group_by { |hit| hit[:line] }
 
         code.each_line.with_index(1) do |line, number|
           stripped = line.strip
 
-          # Detect redirect_to calls
-          if (m = stripped.match(/redirect_to\s+(.+)/))
-            target = m[1].sub(/\s*,\s*(status|notice|alert|flash):.*/, "")
-            desc = "redirect_to #{target.strip}"
-            flash_parts = []
-            flash_parts << "notice: #{Regexp.last_match(1)}" if stripped.match(/notice:\s*("[^"]*"|'[^']*'|[^,)]+)/)
-            flash_parts << "alert: #{Regexp.last_match(1)}" if stripped.match(/alert:\s*("[^"]*"|'[^']*'|[^,)]+)/)
-            desc += " (#{flash_parts.join(', ')})" if flash_parts.any?
-            redirects << desc
-          end
-
-          # Detect render calls
-          if (m = stripped.match(/render\s+(.+)/))
-            render_args = m[1]
-            desc = "render #{render_args.sub(/\s*\}?\s*$/, "").strip}"
-            renders << desc
-          end
-
           # Detect side effects
           if stripped.match?(/\.save[!]?(\s|\(|$)/)
             obj = stripped.match(/(\S+)\.save/)&.send(:[], 1) || "object"
@@ -447,6 +524,56 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, { redirects: [], renders: [], side_effects: [] }, label: "extract_render_map")
       end
 
+      # Each render and redirect_to call as the source writes its arguments.
+      # Lines were matched one at a time and their ends trimmed, which cut the
+      # brace closing a block in `render json: accounts.map { ... }` and the
+      # parenthesis closing `t(".created")` in a redirect's notice.
+      private_class_method def self.render_and_redirect_calls(code)
+        redirects = []
+        renders = []
+        tree = RailsAiContext::AstCache.parse_string(code).value
+        action = tree.statements.body.first.then { |node| node.name if node.is_a?(Prism::DefNode) }
+        visit = lambda do |node|
+          if node.is_a?(Prism::CallNode) && node.receiver.nil? && node.arguments
+            case node.name
+            when :redirect_to then redirects << redirect_text(node.arguments.arguments)
+            when :render then renders << "render #{node.arguments.slice.squish}"
+            end
+          elsif action && implicit_format_render?(node)
+            # `format.turbo_stream` with no block renders the action's own
+            # template for that format, a render no `render` call names.
+            renders << "render :#{action}, formats: :#{node.name} (implicit, from `format.#{node.name}`)"
+          end
+          node.compact_child_nodes.each(&visit)
+        end
+        visit.call(tree)
+        [ redirects, renders ]
+      end
+
+      RESPONSE_FORMATS = %i[html json xml js turbo_stream csv text].freeze
+
+      private_class_method def self.implicit_format_render?(node)
+        node.is_a?(Prism::CallNode) && node.receiver.is_a?(Prism::LocalVariableReadNode) &&
+          RESPONSE_FORMATS.include?(node.name) && node.arguments.nil? && node.block.nil?
+      end
+
+      # `redirect_to target (notice: ..., alert: ...)`: the flash it sets, and
+      # none of the status or other options beside it.
+      private_class_method def self.redirect_text(arguments)
+        options, target = arguments.partition { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        flash = options.flat_map(&:elements).filter_map do |pair|
+          key = pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode) ? pair.key.unescaped : nil
+          "#{key}: #{pair.value.slice.squish}" if %w[notice alert].include?(key)
+        end
+        "redirect_to #{target.map { |arg| arg.slice.squish }.join(", ")}#{" (#{flash.join(', ')})" if flash.any?}"
+      end
+
+      # Source as it is shown: every secret in it filtered, as search_code and
+      # get_edit_context show the same lines.
+      private_class_method def self.redacted(code, path)
+        RailsAiContext::Redaction.redact_source(code, path: path)
+      end
+
       private_class_method def self.extract_method_with_lines(file_path, method_name, source: nil, owner: nil)
         unless source
           return nil unless file_path && File.exist?(file_path)
@@ -461,9 +588,11 @@ module RailsAiContext
 
       private_class_method def self.format_controller(name, info, ctx)
         lines = [ "# #{name}", "" ]
+        lines << "**Alias of:** `#{info[:alias_of]}`, the same class under a second name" if info[:alias_of]
         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?
+        formats = formats_phrase(info, ctx, name)
+        lines << "**Formats:** #{formats}" if formats
         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]
 
@@ -493,8 +622,14 @@ module RailsAiContext
               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}"}"
+                                 Array(sp[:hashes]).map { |key| "#{key}: {}" } +
+                                 Array(sp[:computed]).map { |key, source| "#{key}: #{source}" }).join(", ")
+              shape = if sp[:unrestricted]
+                " #{UNRESTRICTED}"
+              else
+                "#{sp[:requires] ? " (requires: :#{sp[:requires]})" : ""}#{permits_summary.empty? ? "" : " permits: #{permits_summary}"}"
+              end
+              lines << "- `#{sp[:name]}`#{params_origin(sp)}#{shape}"
             else
               lines << "- `#{sp}`"
             end

data/lib/rails_ai_context/tools/get_conventions.rb

@@ -94,8 +94,8 @@ module RailsAiContext
           fingerprint_parts = []
           fingerprint_parts << conventions[:architecture].map { |a| humanize_arch(a) }.join(", ") if conventions[:architecture]&.any?
           fingerprint_parts << conventions[:patterns].map { |p| humanize_pattern(p) }.join(", ") if conventions[:patterns]&.any?
-          top_dirs = conventions[:directory_structure]&.sort_by { |_, v| -v }&.first(5)&.map { |k, _| k }
-          fingerprint_parts << "key dirs: #{top_dirs.join(', ')}" if top_dirs&.any?
+          top_dirs = (conventions[:directory_structure] || {}).sort_by.with_index { |(_, v), i| [ -v, i ] }.first(5).map { |k, _| k }
+          fingerprint_parts << "key dirs: #{top_dirs.join(', ')}" if top_dirs.any?
           if fingerprint_parts.any?
             lines << "" << "## Convention Fingerprint"
             lines << "This app uses #{fingerprint_parts.join('; ')}."
@@ -192,6 +192,15 @@ module RailsAiContext
         stack
       end
 
+      # How a create action checks permission: the app's own `can_x?`,
+      # CanCanCan's `authorize!`, or Pundit's `authorize record`.
+      private_class_method def self.permission_style(block)
+        if block.match?(/\bcan_\w+\??/) then :can_method
+        elsif block.match?(/\bauthorize!/) then :cancan
+        elsif block.match?(/\bauthorize\b/) then :pundit
+        end
+      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
@@ -210,10 +219,14 @@ module RailsAiContext
         html_response_count = 0
         show_only_controllers = []
         has_services = Dir.exist?(rails_app.root.join("app", "services"))
+        permission_styles = []
+        real_controllers_dir = File.realpath(controllers_dir).to_s
 
         safe_glob(controllers_dir, "**/*.rb", real_root).each do |path|
           content = RailsAiContext::SafeFile.read(path) or next
-          controller_name = File.basename(path, ".rb")
+          # The path under app/controllers, so Api::V1::ProductsController is
+          # not a second ProductsController.
+          controller_name = path.delete_prefix("#{real_controllers_dir}/").delete_suffix(".rb")
 
           auth_checks.concat(content.scan(/\b(can_\w+\??)/).flatten)
           auth_denials.concat(content.scan(/redirect_to\s+.+?,\s*alert:\s*"([^"]*)"/).flatten
@@ -235,7 +248,10 @@ module RailsAiContext
             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!/)
+              if (style = permission_style(create_block))
+                flow_parts << "permission check"
+                permission_styles << style
+              end
               flow_parts << "build" if create_block.match?(/\.new\(|\.build\(|\.create\(/)
               # `create!` raises instead of returning false - it is not the
               # save-then-branch flow this skeleton describes.
@@ -305,9 +321,13 @@ module RailsAiContext
           # whichever the app's own create actions use most.
           failure_status = create_error_statuses.tally.max_by { |_, count| count }&.first || "unprocessable_entity"
 
+          # The check the app's own create actions make: a Pundit app
+          # authorizes the record, where the skeleton used to call a
+          # `can_[permission]?` method no Pundit app defines.
+          style = permission_styles.tally.max_by { |_, count| count }&.first
           sections << "```ruby"
           sections << "def create"
-          if has_permission_check
+          if has_permission_check && style == :can_method
             sections << "  unless current_user.can_[permission]?"
             sections << '    redirect_to [path], alert: "[limit message]"'
             sections << "    return"
@@ -316,6 +336,8 @@ module RailsAiContext
             sections << "  @record = current_user.[association].build([params_method])"
           else
             sections << "  @record = [Model].new([params_method])"
+            sections << "  authorize @record" if has_permission_check && style == :pundit
+            sections << "  authorize! :create, @record" if has_permission_check && style == :cancan
           end
           if has_save
             sections << ""
@@ -340,7 +362,7 @@ module RailsAiContext
           sections << "end"
           sections << "```"
           sections << ""
-          sections << "Detected in: #{create_flows.map { |f| f.split(':').first }.join(', ')}"
+          sections << "Detected in: #{create_flows.map { |f| f.split(': ').first }.join(', ')}"
         end
 
         if show_only_controllers.any?

data/lib/rails_ai_context/tools/get_edit_context.rb

@@ -47,33 +47,46 @@ module RailsAiContext
 
         located = RailsAiContext::SafePath.locate(file, under: rails_app.root.to_s)
         case located.refusal
-        when :traversal, :outside then return error_response("Path not allowed: #{file}")
-        when :sensitive then return error_response("Access denied: #{file} is a sensitive file (secrets/keys/credentials).")
+        when :traversal, :outside then return error_response("Path not allowed: #{echo_input(file)}")
+        when :sensitive then return error_response("Path not allowed: #{echo_input(file)} (sensitive file)")
         when :too_large then return text_response("File too large: #{file}")
         when :missing
+          root = rails_app.root.to_s
           basename = File.basename(file)
-          candidates = Dir.glob(File.join(rails_app.root, "app", "**", basename)).first(5)
+          asked = File.expand_path(file, root)
+          # Files of that name the tool would read, never the path asked for:
+          # a link that resolves nowhere is not a file to retry.
+          candidates = RailsAiContext::FileWalk.each_file(File.join(root, "app"), root: root)
+            .select { |path| File.basename(path) == basename && path != asked }.sort.first(5)
           hint = if candidates.any?
-            suggestions = candidates.map { |c| c.sub("#{rails_app.root}/", "") }
+            suggestions = candidates.map { |c| c.delete_prefix("#{root}/") }
             " Did you mean: #{suggestions.join(', ')}? Use the full path relative to Rails root."
           else
-            " Use the full path relative to Rails root (e.g., 'app/models/#{basename}')."
+            # An example built from the name the caller gave was that same
+            # path back for `app/models/nope.rb`, read as a file to retry.
+            " No file named #{echo_input(basename)} is under app/."
           end
-          return empty_response("File not found: #{file}.#{hint}")
+          return empty_response("File not found: #{echo_input(file)}.#{hint}")
         end
         real = located.realpath
 
         source_lines = (RailsAiContext::SafeFile.read(real) || "").lines
         context_lines = [ context_lines.to_i, 0 ].max
 
+        # Source leaving the app passes through Redaction, the whole file at once, so a window
+        # opening inside a PEM key still knows it is inside one. `near` is looked for in the lines
+        # as the caller sees them: found in the file as written, a guess at a filtered value's
+        # start brought back a window where a wrong guess brought "not found".
+        redacted = RailsAiContext::Redaction.redact_source_lines(source_lines.map(&:rstrip), path: file)
+
         # Find all matching lines
         matches = []
-        source_lines.each_with_index do |line, idx|
+        redacted.each_with_index do |line, idx|
           matches << idx if line.include?(near)
         end
 
         if matches.empty?
-          return empty_response("'#{near}' not found in #{file} (#{count_phrase(source_lines.size, "line")}).\n\nAvailable methods:\n#{extract_methods(source_lines)}")
+          return empty_response("'#{echo_input(near)}' not found in #{file} (#{count_phrase(source_lines.size, "line")}).\n\nAvailable methods:\n#{extract_methods(source_lines)}")
         end
 
         # Build context window around first match
@@ -94,9 +107,6 @@ module RailsAiContext
           end_idx = [ end_idx, method_end ].max
         end
 
-        # Source leaving the app passes through Redaction, the whole file at once, so a window
-        # opening inside a PEM key still knows it is inside one.
-        redacted = RailsAiContext::Redaction.redact_source_lines(source_lines.map(&:rstrip), path: file)
         context_code = redacted[start_idx..end_idx].map.with_index do |line, i|
           "#{(start_idx + i + 1).to_s.rjust(4)}  #{line}"
         end.join("\n")
@@ -109,9 +119,12 @@ module RailsAiContext
         else ""
         end
 
-        # Detect enclosing class and method for context
-        class_name = source_lines[0..match_idx].reverse.find { |l| l.match?(/\A\s*(class|module)\s/) }&.strip&.sub(/\s*<.*/, "")
-        method_name = method_start ? source_lines[method_start].strip.sub(/\s*\(.*/, "").sub(/\Adef\s+/, "def ") : nil
+        # Detect enclosing class and method for context, named from the redacted lines: an endless
+        # method's line is its whole body (`def headers = { "Authorization" => "Bearer ..." }`), and
+        # the label keeps its name alone.
+        class_idx = match_idx.downto(0).find { |i| source_lines[i].match?(/\A\s*(class|module)\s/) }
+        class_name = class_idx && redacted[class_idx].strip.sub(/\s*<.*/, "")
+        method_name = method_start ? redacted[method_start].strip.sub(/\s*\(.*/, "").sub(/\s+=\s.*/, "").sub(/\Adef\s+/, "def ") : nil
         context_label = [ class_name, method_name ].compact.join(" > ")
 
         output = [ "# #{file} (lines #{start_idx + 1}-#{end_idx + 1} of #{source_lines.size})", "" ]

data/lib/rails_ai_context/tools/get_env.rb

@@ -98,9 +98,10 @@ module RailsAiContext
 
       # Named in the answer, because a name missing from it is otherwise
       # indistinguishable from a name the app does not read.
-      SCAN_NOTE = "_Scanned `app`, `config` and `lib` for `.rb`, `.rake`, `.erb` and config `.yml`, plus `config.ru`, `db/seeds` and the Ruby scripts in `bin`. " \
-        "Config YAML on `sensitive_patterns` (config/database.yml) is read for the ENV names in its ERB tags only; " \
-        "credentials, keys and the rest are never read._"
+      SCAN_NOTE = "_Scanned `app`, `config` and `lib` for `.rb`, `.rake`, `.erb` and config `.yml`, plus `config.ru`, `db/seeds` and the Ruby scripts in `bin`; " \
+        "a YAML comment line is skipped, since what its ERB tag writes is thrown away. " \
+        "Config YAML on `sensitive_patterns` (config/database.yml, config/cable.yml, config/storage.yml and the rest) is read for the ENV names in its ERB tags only, " \
+        "so a default there is listed as not read; credentials, keys and the rest are never read._"
 
       private_class_method def self.format_standard(env_vars, env_example, deploy_and_settings, external_services, credentials_keys, encrypted_columns)
         lines = [ "# Environment Configuration", "" ]
@@ -127,6 +128,9 @@ module RailsAiContext
                 " (#{DEFAULTS_DIFFER}; `detail:\"full\"` names each)"
               elsif defaults.size == 1 && defaults.first.is_a?(String)
                 " (default: `#{defaults.first}`)"
+              elsif sites.any? && sites.all? { |v| v[:default_unread] }
+                # Read as no default at all, which for a fetch means a KeyError.
+                " (has a default, not read: #{sites.map { |v| "`#{v[:file]}`" }.uniq.join(', ')} is on `sensitive_patterns`)"
               else
                 ""
               end
@@ -207,10 +211,13 @@ module RailsAiContext
         if env_vars.any?
           lines << "## Environment Variables by Category"
 
-          # Build a map: var_name -> { details from all files }
+          # Build a map: var_name -> { details from all files }. The scan
+          # keys each file by its realpath, which under a symlinked root (a
+          # macOS /tmp, /var) starts other than the root as the app names it.
+          real_root = File.realpath(root)
           var_details = {}
           env_vars.sort_by { |file, _| file }.each do |file, vars|
-            relative = file.sub("#{root}/", "")
+            relative = file.delete_prefix("#{real_root}/")
             vars.each do |v|
               var_details[v[:name]] ||= { files: [], defaults: [] }
               var_details[v[:name]][:files] << { file: relative, line: v[:line], default: v[:default],
@@ -238,8 +245,8 @@ module RailsAiContext
               # most needs, since it raises KeyError when the variable is unset.
               file_locations = v[:files].map { |f|
                 at = f[:line] ? "#{f[:file]}:#{f[:line]}" : f[:file]
-                next at unless disagree?(v[:files])
                 next "#{at} default not read" if f[:default_unread]
+                next at unless disagree?(v[:files])
 
                 case f[:default]
                 when String then "#{at} default: `#{f[:default]}`"
@@ -783,10 +790,12 @@ module RailsAiContext
         groups.sort_by { |k, _| CATEGORY_ORDER.index(k) || 99 }
       end
 
-      # Every site each variable is read at.
+      # Every site each variable is read at, with the file it is in.
       private_class_method def self.sites_by_name(env_vars)
-        env_vars.each_value.with_object(Hash.new { |h, k| h[k] = [] }) do |vars, found|
-          vars.each { |v| found[v[:name]] << v }
+        # The scan keys each file by its realpath.
+        root = "#{File.realpath(rails_app.root.to_s)}/"
+        env_vars.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(path, vars), found|
+          vars.each { |v| found[v[:name]] << v.merge(file: path.to_s.delete_prefix(root)) }
         end
       end
 

data/lib/rails_ai_context/tools/get_frontend_stack.rb

@@ -329,7 +329,9 @@ module RailsAiContext
           end
 
           if turbo
-            broadcasts = turbo[:model_broadcasts]&.size || 0
+            # The broadcast_*_to calls as well as the model macros: bazaar's
+            # three explicit broadcasts went uncounted beside its one macro.
+            broadcasts = Array(turbo[:model_broadcasts]).size + Array(turbo[:explicit_broadcasts]).size
             frames = turbo[:turbo_frames]&.size || 0
             parts = []
             parts << count_phrase(broadcasts, "broadcast") if broadcasts > 0

data/lib/rails_ai_context/tools/get_gems.rb

@@ -90,7 +90,7 @@ module RailsAiContext
           elsif page[:total].zero?
             all_cats = (gems[:notable_gems] || []).map { |g| g[:category] }.uniq.sort
             hint = all_cats.any? ? " Available categories: #{all_cats.join(', ')}" : ""
-            lines << "_No notable gems found#{" in category '#{category}'" unless category == 'all'}.#{hint}_"
+            lines << "_No notable gems found#{" in category '#{echo_input(category)}'" unless category == 'all'}.#{hint}_"
           end
           # An empty page past the end is not an empty app. Saying "no notable
           # gems found" above "No items at offset 9999. Total: 13." contradicts