rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/tools/migration_advisor.rb

@@ -98,14 +98,16 @@ module RailsAiContext
           lines << ""
         end
 
-        # Check if table exists
-        table_exists = schema && schema[:tables]&.key?(table)
+        databases = RailsAiContext::Payload.schema_databases(schema, table)
+        table_exists = databases.any?
+        database_lines, target = database_option(table, databases)
+        lines.concat(database_lines)
 
         case action
         when "add_column"
-          lines.concat(generate_add_column(table, column, type, options, table_exists))
+          lines.concat(generate_add_column(table, column, type, options, table_exists, target))
         when "remove_column"
-          lines.concat(generate_remove_column(table, column, type, schema, models))
+          lines.concat(generate_remove_column(table, column, type, schema, models, target))
         when "rename_column"
           rename_to = new_name&.to_s&.strip
           rename_to = type if rename_to.nil? || rename_to.empty?
@@ -113,7 +115,7 @@ module RailsAiContext
         when "add_index"
           lines.concat(generate_add_index(table, column, options))
         when "add_association"
-          lines.concat(generate_add_association(table, column, type, options))
+          lines.concat(generate_add_association(table, column, type, options, schema))
         when "change_type"
           lines.concat(generate_change_type(table, column, type, options))
         when "create_table"
@@ -141,7 +143,42 @@ module RailsAiContext
           parts.join
         end
 
-        def generate_add_column(table, column, type, options, table_exists)
+        # A table only a secondary database holds needs its migration in that database's migrations_paths.
+        # [lines, target]: target is nil for the primary, false when no environment configures the
+        # database, else the generator's --database flag and the RAILS_ENV that configures it.
+        def database_option(table, databases)
+          return [ [], nil ] if databases.empty? || databases.include?("primary")
+
+          yml = RailsAiContext::DatabaseYml
+          root = rails_app.root
+          found = databases.to_h { |db| [ db, (entry = yml.entry(root, db)) ? [ nil, entry ] : yml.elsewhere(root, db) ] }.compact
+          if found.empty?
+            note = "**Database:** `#{table}` is in the #{databases.join(", ")} dump, which no environment in config/database.yml configures: " \
+                   "no `--database` reaches it, and a migration generated here runs on the primary."
+            return [ [ note, "" ], false ]
+          end
+
+          names = found.keys
+          env_name = found.values.first.first
+          target = { flag: " --database #{names.first}", env: env_name }
+          paths = Array(found.values.first.last["migrations_paths"]).join(", ")
+          note = "**Database:** `#{table}` is in #{[ names[0..-2].join(", "), names.last ].reject(&:empty?).join(" and ")}," \
+                 "#{" which #{env_name} configures and this environment does not," if env_name} not the primary database: generate with #{"`RAILS_ENV=#{env_name}` and " if env_name}`#{target[:flag].strip}` " \
+                 "so the migration lands in #{env_name && !paths.empty? ? paths : "that database's migrations_paths"} and " \
+                 "#{"#{env_name}'s " if env_name}`bin/rails db:migrate` runs it there."
+          groups = found.group_by { |_, (_, entry)| Array(entry["migrations_paths"]) }
+          if groups.size > 1
+            note += " Those databases read different migrations_paths, so generate it once per database: " \
+                    "#{groups.values.map { |dbs| "`--database #{dbs.first.first}`" }.join(', ')}."
+          end
+          [ [ note, "" ], target ]
+        end
+
+        def generate_command(args, target)
+          "#{"RAILS_ENV=#{target[:env]} " if target && target[:env]}bin/rails generate migration #{args}#{target && target[:flag]}"
+        end
+
+        def generate_add_column(table, column, type, options, table_exists, target = nil)
           return [ "**Error:** column name is required for add_column" ] unless column
           type ||= "string"
 
@@ -159,10 +196,10 @@ module RailsAiContext
           opts = options ? ", #{options}" : ""
           class_name = migration_class_name("add", table, column)
 
-          lines << "**Run:** `bin/rails generate migration #{class_name} #{column}:#{type}`"
-          lines << ""
+          command = generate_command("#{class_name} #{column}:#{type}", target) unless target == false
+          lines.push("**Run:** `#{command}`", "") if command
           lines << "```ruby"
-          lines << "# rails generate migration #{class_name} #{column}:#{type}"
+          lines << "# #{command.sub("bin/rails", "rails")}" if command
           lines << "class #{class_name} < ActiveRecord::Migration[#{rails_version}]"
           lines << "  def change"
           lines << "    add_column :#{table}, :#{column}, :#{type}#{opts}"
@@ -175,12 +212,12 @@ module RailsAiContext
           lines
         end
 
-        def generate_remove_column(table, column, type, schema, models)
+        def generate_remove_column(table, column, type, schema, models, target = nil)
           return [ "**Error:** column name is required for remove_column" ] unless column
 
           lines = []
 
-          table_exists = schema && schema[:tables]&.key?(table)
+          table_exists = !RailsAiContext::Payload.schema_table(schema, table).nil?
           unless table_exists
             lines << "**Warning:** Table `#{table}` not found in current schema. This migration will fail."
             lines << ""
@@ -196,8 +233,7 @@ module RailsAiContext
           # Check if column is referenced
           col_type = find_column_type(table, column, schema) || type || "string"
 
-          lines << "**Run:** `bin/rails generate migration #{class_name} #{column}:#{col_type}`"
-          lines << ""
+          lines.push("**Run:** `#{generate_command("#{class_name} #{column}:#{col_type}", target)}`", "") unless target == false
           lines << "**Warning:** `remove_column` is irreversible without specifying the column type."
           lines << ""
           lines << "```ruby"
@@ -276,7 +312,7 @@ module RailsAiContext
           lines
         end
 
-        def generate_add_association(table, column, type, options)
+        def generate_add_association(table, column, type, options, schema = nil)
           foreign_table = column || type
           return [ "**Error:** Specify the associated table in column param (e.g., column: 'users')" ] unless foreign_table
 
@@ -287,10 +323,20 @@ module RailsAiContext
             lines << ""
           end
 
+          to_table = foreign_table.singularize.pluralize
+          own = RailsAiContext::Payload.schema_databases(schema, table)
+          theirs = RailsAiContext::Payload.schema_databases(schema, to_table)
+          across = own.any? && theirs.any? && !own.intersect?(theirs)
+          if across
+            lines << "**Foreign key:** `#{to_table}` is in #{theirs.join(' and ')} and `#{table}` in #{own.join(' and ')}; " \
+                     "a foreign key cannot reach another database, so the reference below has none."
+            lines << ""
+          end
+
           lines << "```ruby"
           lines << "class Add#{foreign_table.camelize}To#{table.camelize} < ActiveRecord::Migration[#{rails_version}]"
           lines << "  def change"
-          lines << "    add_reference :#{table}, :#{foreign_table.singularize}, foreign_key: true"
+          lines << "    add_reference :#{table}, :#{foreign_table.singularize}#{", foreign_key: true" unless across}"
           lines << "  end"
           lines << "end"
           lines << "```"
@@ -495,9 +541,7 @@ module RailsAiContext
 
         def column_exists?(table, column)
           schema = cached_context[:schema]
-          return false unless schema.is_a?(Hash) && schema[:tables]
-
-          table_data = schema[:tables][table]
+          table_data = RailsAiContext::Payload.schema_table(schema, table)
           return false unless table_data
 
           col_str = column.to_s
@@ -506,9 +550,7 @@ module RailsAiContext
 
         def index_exists?(table, column)
           schema = cached_context[:schema]
-          return false unless schema.is_a?(Hash) && schema[:tables]
-
-          table_data = schema[:tables][table]
+          table_data = RailsAiContext::Payload.schema_table(schema, table)
           return false unless table_data
 
           # add_index collides only with the name it would give the index; a
@@ -521,9 +563,7 @@ module RailsAiContext
         end
 
         def find_column_type(table, column, schema)
-          return nil unless schema.is_a?(Hash) && schema[:tables]
-
-          table_data = schema[:tables][table]
+          table_data = RailsAiContext::Payload.schema_table(schema, table)
           return nil unless table_data
 
           col = (table_data[:columns] || []).find { |c| c[:name] == column }

data/lib/rails_ai_context/tools/onboard.rb

@@ -5,7 +5,7 @@ module RailsAiContext
     class Onboard < BaseTool
       tool_name "rails_onboard"
       description "Get a narrative walkthrough of the Rails application - stack, data model, authentication, key flows, " \
-        "background jobs, frontend, testing, and getting started instructions. " \
+        "background jobs, frontend, testing, getting started instructions, and the app's custom rake tasks, generators and Railties. " \
         "Use when: first encountering a project, onboarding a new developer, or orienting an AI agent. " \
         "Key params: detail (quick/standard/full)."
 
@@ -28,11 +28,14 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
-      STANDARD_SECTIONS = %i[stack data_model auth key_flows jobs frontend testing getting_started].freeze
+      STANDARD_SECTIONS = %i[stack data_model auth key_flows jobs frontend testing getting_started rake_tasks generators].freeze
       FULL_SECTIONS = %i[
         stack data_model auth key_flows jobs frontend payments realtime storage api devops i18n engines env
-        testing getting_started
+        testing getting_started all_rake_tasks generators
       ].freeze
+      AUTH_GEMS = %w[devise omniauth rodauth-rails sorcery clearance authlogic].freeze
+      AUTHZ_GEMS = %w[pundit cancancan action_policy rolify].freeze
+      RAKE_TASKS_SHOWN = 15
 
       def self.call(detail: "standard", server_context: nil)
         ctx = cached_context
@@ -58,14 +61,14 @@ module RailsAiContext
         def compose_quick(ctx)
           app = ctx[:app_name] || "This Rails app"
 
-          version = named_ruby_version(ctx)
+          ruby = ruby_phrase(ctx)
           rails = named_rails_version(ctx)
           head = "**#{app}** is a Rails#{" #{rails}" if rails}"
           # The slash pairs two versions; with no Rails version to pair, the
           # Ruby one follows the noun instead of sitting in front of it.
-          head += " / Ruby #{version}" if version && rails
+          head += " / #{ruby}" if ruby && rails
           parts = [ head, "app" ]
-          parts << "running Ruby #{version}" if version && !rails
+          parts << "running #{ruby}" if ruby && !rails
 
           # Stats: tables, models, jobs
           stats = []
@@ -97,10 +100,18 @@ module RailsAiContext
           tests = Payload.section(ctx, :tests)
           if tests
             framework = tests[:framework]
-            parts << (RailsAiContext::TestFramework.none?(framework) ? "with no tests yet" : "tested with #{framework || 'unknown framework'}")
+            parts << if RailsAiContext::TestFramework.none?(framework) then "with no tests yet"
+            elsif framework == RailsAiContext::TestFramework::NOT_READ then "with its tests not read"
+            else "tested with #{framework || 'unknown framework'}"
+            end
           end
 
-          parts.join(" ") + "."
+          [ parts.join(" ") + ".", unread_bundle(rails) ].compact.join(" ")
+        end
+
+        def unread_bundle(rails)
+          unread = RailsAiContext::GemLock.for(rails_app.root).unread_bundle unless rails
+          "Its gems and Rails version are not read: #{unread}." if unread
         end
 
         def compose_standard(ctx)
@@ -129,11 +140,15 @@ module RailsAiContext
           elsif RailsAiContext::AppKind.mongoid?(rails_app.root)
             database = RailsAiContext::AppKind.mongoid_database(rails_app.root)
             db = "MongoDB through Mongoid#{" (database #{database})" if database}"
+          elsif !RailsAiContext::AppKind.active_record?(rails_app.root)
+            db = nil
           else
-            db = "unknown"
+            db = RailsAiContext::SchemaAdapter.label(ctx)
           end
           rails = named_rails_version(ctx)
-          lines << "#{ctx[:app_name]} is a Rails#{" #{rails}" if rails} application#{ruby_clause(ctx)} on #{db}."
+          lines << "#{ctx[:app_name]} is a Rails#{" #{rails}" if rails} application#{ruby_clause(ctx)} #{db ? "on #{db}" : "without Active Record"}."
+          unread = unread_bundle(rails)
+          lines << unread if unread
 
           notable = Payload.notable_gems(ctx)
           if notable.any?
@@ -190,64 +205,58 @@ module RailsAiContext
         end
 
         def section_auth(ctx)
-          auth = Payload.section(ctx, :auth)
-          lines = [ "## Authentication & Authorization", "" ]
-          has_content = false
+          auth = Payload.section(ctx, :auth) || {}
+          gem_authn, gem_authz = auth_gem_lines(ctx)
+          # Each half falls back to the gems on its own: a policy directory says nothing about login.
+          authn = authentication_lines(auth).presence || gem_authn
+          authz = authorization_lines(auth).presence || gem_authz
+          found = authn + Introspectors::AuthIntrospector.digest_sentences(auth[:authentication]) + authz
+          return [] if found.empty?
+
+          [ "## Authentication & Authorization", "", *found, "" ]
+        end
 
-          if auth
-            authentication = auth[:authentication] || {}
-            authorization = auth[:authorization] || {}
-            if authentication[:method]
-              lines << "Authentication is handled by #{authentication[:method]}."
-              has_content = true
-            end
-            if authentication[:model]
-              lines << "The #{authentication[:model]} model handles user accounts."
-              has_content = true
-            end
-            if authorization[:method]
-              lines << "Authorization uses #{authorization[:method]}."
-              has_content = true
-            end
+        # What the auth introspector writes, one sentence per finding.
+        def authentication_lines(auth)
+          authn = auth[:authentication] || {}
+          modules = auth[:devise_modules_per_model] || {}
+          lines = Array(authn[:devise]).map do |entry|
+            used = Array(modules[entry[:model]])
+            "Authentication via Devise on #{entry[:model]}#{" (#{used.join(', ')})" if used.any?}."
           end
-
-          # Fallback: detect auth from gems if introspector didn't provide data
-          unless has_content
-            notable = Payload.notable_gems(ctx)
-            if notable.any?
-              auth_gem_names = %w[devise omniauth rodauth sorcery clearance authlogic]
-              auth_gems = notable.select { |g| g.is_a?(Hash) && auth_gem_names.include?(g[:name].to_s) }
-              if auth_gems.any?
-                lines << "Authentication via #{auth_gems.map { |g| "#{g[:name]}#{g[:version] ? " (#{g[:version]})" : ""}" }.join(', ')}."
-                has_content = true
-              end
-              authz_gem_names = %w[pundit cancancan action_policy rolify]
-              authz_gems = notable.select { |g| g.is_a?(Hash) && authz_gem_names.include?(g[:name].to_s) }
-              if authz_gems.any?
-                lines << "Authorization via #{authz_gems.map { |g| g[:name] }.join(', ')}."
-                has_content = true
-              end
-            end
+          lines << "Authentication via the Rails authentication generator (Session and Current models)." if authn[:rails_auth]
+          if (rodauth = authn[:rodauth])
+            classes = Array(rodauth[:classes])
+            lines << "Authentication via Rodauth#{" (#{classes.join(', ')})" if classes.any?}."
           end
+          lines << "has_secure_password on #{authn[:has_secure_password].join(', ')}." if Array(authn[:has_secure_password]).any?
+          lines << "OmniAuth providers: #{authn[:omniauth_providers].join(', ')}." if Array(authn[:omniauth_providers]).any?
+          lines
+        end
 
-          # Fallback: detect from conventions (global before_actions like authenticate_user!)
-          unless has_content
-            conv = Payload.section(ctx, :conventions)
-            if conv
-              before_acts = Array(conv[:before_actions]).select { |a| a.to_s.match?(/authenticat|authorize/) }
-              auth_checks = Array(conv[:authorization_checks]) + before_acts
-              if auth_checks.any?
-                lines << "Auth checks detected: #{auth_checks.first(5).join(', ')}."
-                has_content = true
-              end
-            end
+        def authorization_lines(auth)
+          authz = auth[:authorization] || {}
+          lines = []
+          { pundit: "Pundit", action_policy: "Action Policy" }.each do |key, label|
+            lines << "Authorization via #{label} (#{count_phrase(authz[key].size, "policy")})." if Array(authz[key]).any?
           end
-
-          return [] unless has_content
-          lines << ""
+          lines << "#{count_phrase(authz[:policies].size, "policy class")} in app/policies." if Array(authz[:policies]).any?
+          lines << "Authorization via CanCanCan (app/models/ability.rb)." if authz[:cancancan]
+          lines << "An Ability class in #{authz[:ability_class]}." if authz[:ability_class]
           lines
         end
 
+        # [authentication lines, authorization lines] named from the notable gems alone.
+        def auth_gem_lines(ctx)
+          notable = Payload.notable_gems(ctx).select { |g| g.is_a?(Hash) }
+          authn = notable.select { |g| AUTH_GEMS.include?(g[:name].to_s) }
+          authz = notable.select { |g| AUTHZ_GEMS.include?(g[:name].to_s) }
+          [
+            authn.any? ? [ "Authentication via #{authn.map { |g| "#{g[:name]}#{" (#{g[:version]})" if g[:version]}" }.join(', ')}." ] : [],
+            authz.any? ? [ "Authorization via #{authz.map { |g| g[:name] }.join(', ')}." ] : []
+          ]
+        end
+
         def section_key_flows(ctx)
           routes = Payload.section(ctx, :routes)
           return [] unless routes
@@ -361,9 +370,7 @@ module RailsAiContext
           framework = tests[:framework] || "unknown"
           lines << "Framework: #{framework}."
 
-          factories = tests[:factories]
-          fixtures = tests[:fixtures]
-          lines << "Data setup: #{factories ? "FactoryBot (#{factory_phrase(tests)})" : fixtures ? "fixtures (#{RailsAiContext::TestFramework.fixture_phrase(fixtures)})" : "inline"}."
+          lines << "Data setup: #{data_setup_phrase(tests)}." unless framework == RailsAiContext::TestFramework::NOT_READ
 
           ci = tests[:ci_config]
           lines << "CI: #{ci.join(', ')}." if ci&.any?
@@ -377,12 +384,32 @@ module RailsAiContext
           lines
         end
 
+        def data_setup_phrase(tests)
+          if tests[:factories]
+            "FactoryBot (#{factory_phrase(tests)})"
+          elsif tests[:fabricators]
+            "Fabrication (#{fabricator_phrase(tests)})"
+          elsif tests[:fixtures]
+            "fixtures (#{RailsAiContext::TestFramework.fixture_phrase(tests[:fixtures])})"
+          else
+            "inline"
+          end
+        end
+
+        def fabricator_phrase(tests)
+          files = count_phrase(tests[:fabricators][:count].to_i, "file")
+          names = tests[:fabricator_names]
+          return files unless names.is_a?(Hash) && names.any?
+
+          "#{count_phrase(names.values.sum { |list| Array(list).size }, "fabricator")} in #{files}"
+        end
+
         # The factories a suite defines, and the files they sit in: one file
         # commonly defines several, so the file count is not the factory count.
         def factory_phrase(tests)
-          files = count_phrase(tests[:factories][:count].to_i, "file")
+          files = RailsAiContext::TestFramework.factory_files_phrase(tests[:factories])
           names = tests[:factory_names]
-          return files unless names.is_a?(Hash) && names.any?
+          return files || "files not read" unless names.is_a?(Hash) && names.any?
 
           # A factory named in a loop defines at least one, so the count is a floor.
           computed = tests[:computed_factories].to_i
@@ -406,6 +433,54 @@ module RailsAiContext
           ].compact
         end
 
+        def section_rake_tasks(ctx, limit: RAKE_TASKS_SHOWN)
+          tasks = Payload.list(ctx, :rake_tasks, :tasks)
+          return [] if tasks.empty?
+
+          limit ||= tasks.size
+          lines = [ "## Rake Tasks", "" ]
+          tasks.first(limit).each { |task| lines << rake_task_line(task) }
+          lines << "...#{tasks.size - limit} more: `detail:\"full\"` lists every task." if tasks.size > limit
+          lines << ""
+        end
+
+        def section_all_rake_tasks(ctx)
+          section_rake_tasks(ctx, limit: nil)
+        end
+
+        def section_generators(ctx)
+          data = Payload.section(ctx, :rake_tasks) || {}
+          generators = Array(data[:generators])
+          templates = Array(data[:generator_templates])
+          railties = Array(data[:railties])
+          return [] if generators.empty? && templates.empty? && railties.empty?
+
+          lines = [ "## Generators and Railties", "" ]
+          generators.each do |g|
+            lines << "- `#{g[:command]}`#{" - #{g[:usage]}" if g[:usage]} (`#{g[:file]}`)"
+          end
+          templates.each do |t|
+            lines << "- `#{t[:file]}` replaces the template the `#{t[:generator]}` generator writes"
+          end
+          railties.each do |r|
+            line = "- Railtie `#{r[:name]}` (`#{r[:file]}`)"
+            notes = []
+            notes << "initializers #{r[:initializers].map { |i| "`#{i}`" }.join(', ')}" if Array(r[:initializers]).any?
+            notes << "adds rake tasks" if r[:rake_tasks]
+            lines << (notes.any? ? "#{line}: #{notes.join('; ')}" : line)
+          end
+          lines << ""
+        end
+
+        def rake_task_line(task)
+          return "- `#{task[:file]}`: not read (#{task[:error]})" if task[:error]
+
+          args = Array(task[:args])
+          line = "- `#{task[:name]}#{"[#{args.join(',')}]" if args.any?}`"
+          line += " - #{task[:description]}" if task[:description]
+          line + " (`#{task[:file]}`)"
+        end
+
         # ── Full-only sections ───────────────────────────────────────────
 
         def section_payments(ctx)
@@ -470,34 +545,29 @@ module RailsAiContext
           text = Payload.section(ctx, :action_text)
           return [] unless storage || text
 
-          lines = [ "## File Storage & Rich Text", "" ]
+          lines = []
           if storage && storage[:attachments]&.any?
             lines << "Active Storage: #{count_phrase(storage[:attachments].size, "attachment")} across models."
           end
           if text && text[:models]&.any?
             lines << "Action Text: #{count_phrase(text[:models].size, "model")} with rich text fields."
           end
-          lines << ""
-          lines
+          return [] if lines.empty?
+
+          [ "## File Storage & Rich Text", "", *lines, "" ]
         end
 
         def section_api(ctx)
           api = Payload.section(ctx, :api)
           return [] unless api
-          return [] if api.empty? || (api[:endpoints]&.empty? && api[:graphql].nil?)
 
-          lines = [ "## API", "" ]
-          if api[:graphql]
-            lines << "GraphQL API detected."
-          end
-          if api[:endpoints]&.any?
-            lines << "#{count_phrase(api[:endpoints].size, "API endpoint")}."
-          end
-          if api[:serializers]&.any?
-            lines << "Serializers: #{api[:serializers].size}."
-          end
-          lines << ""
-          lines
+          lines = []
+          lines << "GraphQL API detected." if api[:graphql]
+          serialization = GetApi.serialization_found(api)
+          lines << "Serialization: #{serialization}." if serialization
+          return [] if lines.empty?
+
+          [ "## API", "", *lines, "" ]
         end
 
         def section_devops(ctx)
@@ -506,9 +576,11 @@ module RailsAiContext
           has_content = false
 
           if devops
-            lines << "Dockerfile: #{devops[:dockerfile] ? 'present' : 'not found'}."
-            lines << "Procfile: #{devops[:procfile] ? 'present' : 'not found'}." if devops.key?(:procfile)
-            deploy = devops[:deployment_method]
+            lines << "Dockerfile: #{devops[:docker] ? 'present' : 'not found'}."
+            procfiles = Array(devops[:procfile]).map { |procfile| procfile[:file] }
+            lines << "Procfile: #{procfiles.include?('Procfile') ? 'present' : 'not found'}."
+            lines << "Procfile.dev: present." if procfiles.include?("Procfile.dev")
+            deploy = devops[:deployment]
             lines << "Deployment: #{deploy}." if deploy
             has_content = true
           end
@@ -517,7 +589,7 @@ module RailsAiContext
           unless has_content
             root = rails_app.root.to_s
             has_dockerfile = File.exist?(File.join(root, "Dockerfile")) || File.exist?(File.join(root, "Dockerfile.dev"))
-            has_procfile = File.exist?(File.join(root, "Procfile")) || File.exist?(File.join(root, "Procfile.dev"))
+            has_procfile = File.exist?(File.join(root, "Procfile"))
             has_ci = Dir.exist?(File.join(root, ".github", "workflows")) || File.exist?(File.join(root, ".gitlab-ci.yml"))
 
             if has_dockerfile || has_procfile || has_ci
@@ -551,7 +623,11 @@ module RailsAiContext
           mounted.each do |e|
             name = e[:engine]
             path = e[:path]
-            lines << (path ? "- **#{name}** at `#{path}`" : "- **#{name}**") if name
+            next unless name
+
+            line = path ? "- **#{name}** at `#{path}`" : "- **#{name}**"
+            line += " (`#{e[:condition]}`)" if e[:condition]
+            lines << line
           end
           lines << ""
           lines
@@ -588,10 +664,20 @@ module RailsAiContext
         # is the interpreter running this tool, which says nothing about the
         # app. Then the sentence names no Ruby at all.
         def ruby_clause(ctx)
+          ruby = ruby_phrase(ctx)
+          return "" unless ruby
+
+          ctx[:tier].to_s == "static" ? " declaring #{ruby}" : " running #{ruby}"
+        end
+
+        # "Ruby 3.4.9", or the engine first ("JRuby 9.4.8.0 (Ruby 3.1.4)"):
+        # JRuby's own version is not the Ruby version it implements.
+        def ruby_phrase(ctx)
           version = named_ruby_version(ctx)
-          return "" unless version
+          engine = ctx[:ruby_engine].to_s
+          return version && "Ruby #{version}" if engine.empty?
 
-          ctx[:tier].to_s == "static" ? " declaring Ruby #{version}" : " running Ruby #{version}"
+          version ? "#{engine} (Ruby #{version})" : engine
         end
 
         # The version a sentence may name, or nil. Statically that is the one

data/lib/rails_ai_context/tools/performance_check.rb

@@ -66,24 +66,16 @@ module RailsAiContext
 
           lines = [ "# Performance Analysis", "" ]
 
-          # Collect all items then filter, so the count reflects actual displayed results
-          all_sections = CATEGORIES.transform_values { |(key, _, _)| data[key] || [] }
-
-          # Apply model filter to count
-          filtered_count = if model && !model.empty?
-            all_sections.values.sum { |items| filter_items(items, model).size }
-          elsif category != "all"
-            (all_sections[category] || []).size
-          else
-            all_sections.values.sum(&:size)
-          end
+          kept = CATEGORIES.select { |name, _| category == "all" || category == name }
+            .to_h { |name, (key, _, _)| [ name, filter_items(data[key], model) ] }
+          filtered_count = kept.values.sum(&:size)
 
           lines << "**Total issues found:** #{filtered_count}"
           lines << ""
 
           if RailsAiContext::DetailLevel.summary?(detail)
-            CATEGORIES.each do |name, (_, label, _)|
-              items = filter_items(all_sections[name], model)
+            kept.each do |name, items|
+              label = CATEGORIES[name][1]
               counts = name == "n_plus_one" ? risk_summary_counts(items) : ""
               lines << "- #{label}: #{items.size}#{counts}"
             end