rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/tools/onboard.rb

@@ -74,8 +74,11 @@ module RailsAiContext
           stats = []
           schema = Payload.section(ctx, :schema)
           if schema
-            table_count = schema[:total_tables] || 0
-            stats << count_phrase(table_count, "table") if table_count > 0
+            own = own_secondary_databases(ctx, schema)
+            table_count = schema[:total_tables].to_i + own.sum { |db| db[:tables] }
+            if table_count > 0
+              stats << count_phrase(table_count, "table") + (own.any? ? " in #{count_phrase(own.size + 1, "database")}" : "")
+            end
           end
 
           models = Payload.models(ctx)
@@ -137,6 +140,10 @@ module RailsAiContext
             # Prefer live adapter from config over static_parse from schema introspector
             adapter = RailsAiContext::SchemaAdapter.label(ctx)
             db = "#{adapter} (#{count_phrase(schema[:total_tables].to_i, 'table')})"
+            # Every database the app's own dumps declare, as rails_get_schema reads them.
+            own_secondary_databases(ctx, schema).each do |other|
+              db += ", plus the #{other[:name]} database#{" on #{other[:adapter]}" if other[:adapter]} (#{count_phrase(other[:tables], 'table')})"
+            end
           elsif RailsAiContext::AppKind.mongoid?(rails_app.root)
             database = RailsAiContext::AppKind.mongoid_database(rails_app.root)
             db = "MongoDB through Mongoid#{" (database #{database})" if database}"
@@ -147,6 +154,10 @@ module RailsAiContext
           end
           rails = named_rails_version(ctx)
           lines << "#{ctx[:app_name]} is a Rails#{" #{rails}" if rails} application#{ruby_clause(ctx)} #{db ? "on #{db}" : "without Active Record"}."
+          solid = schema ? solid_databases(schema) : {}
+          if solid.any?
+            lines << "#{solid.values.uniq.to_sentence} keep#{"s" if solid.values.uniq.one?} their tables in databases of their own: #{solid.keys.join(", ")}."
+          end
           unread = unread_bundle(rails)
           lines << unread if unread
 
@@ -167,6 +178,25 @@ module RailsAiContext
           lines
         end
 
+        # {database name => the framework whose tables are all it holds}: the
+        # queue, cache and cable databases Rails 8 gives Solid Queue, Solid
+        # Cache and Solid Cable are infrastructure, not the app's data.
+        def solid_databases(schema)
+          Payload.framework_databases(schema).to_h { |name, info| [ name.to_s, Payload.database_framework(info) ] }
+        end
+
+        # The app's own databases besides the primary, as its schema dumps
+        # declare them: metrics71's analytics database on SQLite went
+        # uncounted beside its PostgreSQL primary. Each is
+        # { name:, adapter:, tables: }, the adapter nil when database.yml does not say.
+        def own_secondary_databases(ctx, schema)
+          configured = Array(Payload.section(ctx, :multi_database)&.dig(:databases)).grep(Hash).to_h { |d| [ d[:name].to_s, d ] }
+          Payload.app_databases(schema).map do |name, db|
+            { name: name.to_s, adapter: RailsAiContext::SchemaAdapter.database_label(configured[name.to_s]),
+              tables: (db[:total_tables] || db[:tables].size).to_i }
+          end
+        end
+
         def section_data_model(ctx)
           models = Payload.models(ctx)
           return [] unless models.any?
@@ -183,7 +213,11 @@ module RailsAiContext
             assocs = Serializers::SectionFacts.associations_list(data)
             validations = data[:validations] || []
             desc = "**#{name}**"
-            desc += " (table: `#{data[:table_name]}`)" if data[:table_name]
+            if (note = Serializers::SectionFacts.table_note(Payload.section(ctx, :schema), data))
+              desc += " (table #{note})"
+            elsif data[:table_name]
+              desc += " (table: `#{data[:table_name]}`)"
+            end
             desc += " - #{assocs.first(4).join(', ')}" if assocs.any?
             desc += ", +#{assocs.size - 4} more" if assocs.size > 4
             if validations.any?
@@ -265,7 +299,7 @@ module RailsAiContext
 
           # Controllers with the most actions carry the app's key flows.
           app_ctrls = RouteCoverage.app_controllers(routes)
-          top_ctrls = app_ctrls.sort_by { |_, routes_list| -routes_list.size }.first(5)
+          top_ctrls = app_ctrls.sort_by.with_index { |(_, routes_list), i| [ -routes_list.size, i ] }.first(5)
 
           top_ctrls.each do |ctrl, ctrl_routes|
             actions = ctrl_routes.map { |r| r[:action] }.compact.uniq
@@ -490,7 +524,13 @@ module RailsAiContext
 
           payment_gems = %w[stripe pay braintree paddle_pay]
           found = Payload.notable_gems(ctx).select { |g| payment_gems.include?(g[:name]) }
-          payment_models = models.keys.select { |m| m.downcase.match?(/payment|subscription|charge|invoice|plan|billing/) }
+          named = ->(name) { name.to_s.downcase.match?(/payment|subscription|charge|invoice|plan|billing/) }
+          # An STI subclass is a payment model by its parent: BankTransfer < Payment.
+          payment_models = models.keys.select do |m|
+            chain = [ m ]
+            chain << models.dig(chain.last, :parent_model) while models.dig(chain.last, :parent_model) && chain.size < 10
+            chain.compact.any?(&named)
+          end
           return [] if found.empty? && payment_models.empty?
 
           lines = [ "## Payments", "" ]
@@ -511,9 +551,13 @@ module RailsAiContext
             has_content = true
           end
 
-          broadcasts = Payload.model_broadcasts(ctx)
-          if broadcasts.any?
-            lines << "Turbo Stream broadcasts: #{count_phrase(broadcasts.size, "broadcast point")}."
+          # The broadcast_*_to calls as well as the model macros: bazaar's
+          # three explicit broadcasts went uncounted beside its one macro.
+          macros = Payload.model_broadcasts(ctx).size
+          calls = Payload.explicit_broadcasts(ctx).size
+          if macros + calls > 0
+            kinds = [ (count_phrase(macros, "model macro") if macros > 0), (count_phrase(calls, "broadcast call") if calls > 0) ].compact
+            lines << "Turbo Stream broadcasts: #{count_phrase(macros + calls, "broadcast point")} (#{kinds.join(', ')})."
             has_content = true
           end
           streams = Payload.turbo_streams(ctx)

data/lib/rails_ai_context/tools/performance_check.rb

@@ -137,7 +137,7 @@ module RailsAiContext
           return [] if filtered.empty?
 
           # Sort by risk: high → medium → low
-          sorted = filtered.sort_by { |i| RISK_ORDER[i[:risk].to_s] || 99 }
+          sorted = filtered.sort_by.with_index { |item, i| [ RISK_ORDER[item[:risk].to_s] || 99, i ] }
 
           lines = [ "## N+1 Query Risks (#{sorted.size})#{risk_summary_counts(sorted)}", "" ]
 
@@ -153,12 +153,14 @@ module RailsAiContext
 
         # One association can be at risk in several actions, and those are
         # different findings. Without the call site on the row they read as
-        # one line printed twice, and the section count stops adding up.
+        # one line printed twice, and the section count stops adding up. The
+        # view is where the loop reads the association.
         def call_site(item)
           return "" unless item[:controller]
 
           action = item[:action] ? "##{item[:action]}" : ""
-          " (#{item[:controller]}#{action})"
+          view = item[:view] ? ", in #{item[:view]}" : ""
+          " (#{item[:controller]}#{action}#{view})"
         end
 
         def render_section(title, items, model_filter, detail)