rails-ai-context 5.30.0 → 5.30.2

data/lib/rails_ai_context/schema_adapter.rb

@@ -49,7 +49,7 @@ module RailsAiContext
       context = {} unless context.is_a?(Hash)
       schema = context[:schema]
       observed = schema.is_a?(Hash) ? schema[:adapter] : nil
-      return observed unless placeholder?(observed)
+      return display(observed) unless placeholder?(observed)
 
       # Best first: the app's own database config, which needs no connection.
       # Then what the schema proves, then the example database files (often SQLite for
@@ -58,6 +58,11 @@ module RailsAiContext
         from_examples(context) || from_gems(context) || "unknown"
     end
 
+    # A connection's adapter_name as the other surfaces name it (PostGIS is PostgreSQL).
+    def display(adapter_name)
+      DIALECTS.fetch(adapter_name.to_s.downcase, adapter_name)
+    end
+
     def label_with_reason(context)
       shown = label(context)
       undecided?(shown) ? "#{shown}, #{undecided_reason(context, shown)}" : shown

data/lib/rails_ai_context/serializers/claude_rules_serializer.rb

@@ -104,7 +104,7 @@ module RailsAiContext
           col_str = col_sample.any? ? " - #{col_sample.join(', ')}" : ""
 
           # Foreign keys
-          fks = (data[:foreign_keys] || []).map { |f| "#{f[:column]}→#{f[:to_table]}" }
+          fks = (data[:foreign_keys] || []).map { |f| "#{Introspectors::SchemaConventions.key_text(f[:column])}→#{f[:to_table]}" }
           fk_str = fks.any? ? " | FK: #{fks.join(', ')}" : ""
 
           # Key indexes (unique or composite)

data/lib/rails_ai_context/serializers/context_file_serializer.rb

@@ -103,8 +103,8 @@ module RailsAiContext
           filepath = File.join(output_dir, filename)
 
           # generate_root_files = false is a deliberate omission, so it is
-          # reported rather than dropped.
-          unless generate_root
+          # reported rather than dropped. The JSON dump is no tool's root file.
+          unless generate_root || fmt == :json
             not_applicable[filepath] = "root files disabled"
             next
           end

data/lib/rails_ai_context/serializers/cursor_rules_serializer.rb

@@ -42,6 +42,11 @@ module RailsAiContext
         # user content above/below the gem-managed block survives every
         # `rails ai:context` regeneration.
         cursorrules_path = File.join(output_dir, ".cursorrules")
+        unless RailsAiContext.configuration.generate_root_files
+          result[:not_applicable][cursorrules_path] = "root files disabled"
+          return result
+        end
+
         case SectionMarkerWriter.write_with_markers(cursorrules_path, render_cursorrules_legacy)
         when :written then result[:written] << cursorrules_path
         when :skipped then result[:skipped] << cursorrules_path

data/lib/rails_ai_context/tasks/rails_ai_context.rake

@@ -25,7 +25,7 @@ def print_result(result)
 end unless defined?(print_result)
 
 def abort_boot_failure(result, timeout)
-  $stderr.puts "Error: Rails app failed to boot: #{result.failure_summary}"
+  $stderr.puts "Error: Rails app failed to boot: #{result.failure_summary(full: true)}"
   if result.error.is_a?(RailsAiContext::BootManager::BootTimeoutError)
     $stderr.puts "  If the app is healthy but slow, raise RAILS_AI_CONTEXT_BOOT_TIMEOUT (seconds, current: #{timeout})."
   end

data/lib/rails_ai_context/tools/base_tool.rb

@@ -887,15 +887,16 @@ module RailsAiContext
         #
         # @return [MCP::Tool::Response, nil] the error result, or nil to carry on
         def refuse_unsafe_paths(paths)
-          refused = Array(paths).compact.reject { |path| path.to_s.strip.empty? }.filter_map do |path|
-            refusal = RailsAiContext::SafePath.locate(path.to_s, under: rails_app.root.to_s).refusal
-            [ path, refusal ] if %i[sensitive traversal outside].include?(refusal)
-          end
-          return nil if refused.empty?
+          refused = Array(paths).compact.reject { |path| path.to_s.strip.empty? }.filter_map { |path| unsafe_path_message(path) }
+          error_response(refused.join("\n")) if refused.any?
+        end
 
-          error_response(refused.map { |path, refusal|
-            refusal == :sensitive ? "Path not allowed: #{path} (sensitive file)" : "Path not allowed: #{path}"
-          }.join("\n"))
+        # @return [String, nil] the refusal for a path the caller may not read
+        def unsafe_path_message(path)
+          case RailsAiContext::SafePath.locate(path.to_s, under: rails_app.root.to_s).refusal
+          when :traversal, :outside then "Path not allowed: #{path}"
+          when :sensitive then "Path not allowed: #{path} (sensitive file)"
+          end
         end
 
         # Resolve a Dir.glob result to a realpath that is:

data/lib/rails_ai_context/tools/diagnose.rb

@@ -114,6 +114,9 @@ module RailsAiContext
 
         parsed = parse_error(error)
         classification = classify_error(parsed)
+        # A refused path is said once and then read, traced and suggested nowhere.
+        refusal = file && unsafe_path_message(file)
+        file = nil if refusal
 
         lines = [ "# Error Diagnosis", "" ]
         lines << "**Error:** `#{parsed[:exception_class] || 'Unknown'}`"
@@ -135,6 +138,7 @@ module RailsAiContext
 
         # Gather context based on parameters and error type
         context_sections = gather_context(parsed, classification, file, line, action)
+        context_sections = [ "## Code Context", refusal, "" ] + context_sections if refusal
 
         # Recent git changes
         git_section = gather_git_context(file, parsed[:file_refs])

data/lib/rails_ai_context/tools/generate_test.rb

@@ -393,6 +393,25 @@ module RailsAiContext
                   end
                 when "format"
                   lines << "    @#{setup_var}.#{attr} = \"invalid-format\""
+                when "absence"
+                  lines << "    @#{setup_var}.#{attr} = \"present\""
+                when "confirmation"
+                  lines << "    @#{setup_var}.#{attr} = \"secret\""
+                  lines << "    @#{setup_var}.#{attr}_confirmation = \"different\""
+                when "acceptance"
+                  lines << "    @#{setup_var}.#{attr} = \"0\""
+                when "exclusion"
+                  excluded = v.dig(:options, :in)
+                  if excluded.is_a?(Array) && excluded.any?
+                    lines << "    @#{setup_var}.#{attr} = #{excluded.first.inspect}"
+                  else
+                    lines.push("    skip \"set #{attr} to a value the exclusion list holds\"", "  end", "")
+                    next
+                  end
+                else
+                  # With no value known to break it, the assert would run on a valid record.
+                  lines.push("    skip \"implement #{v[:kind]} validation test\"", "  end", "")
+                  next
                 end
                 lines << "    assert_not @#{setup_var}.valid?#{"(:#{validation_context(v)})" if validation_context(v)}"
                 lines << "  end"

data/lib/rails_ai_context/tools/get_model_details.rb

@@ -213,7 +213,7 @@ module RailsAiContext
             detail += " [polymorphic]" if a[:polymorphic]
             detail += (a[:optional] == true ? " [optional]" : " [optional: #{a[:optional]}]") if a[:optional]
             detail += " dependent: #{a[:dependent]}" if a[:dependent]
-            detail += " (fk: #{a[:foreign_key]})" if a[:foreign_key] && a[:type] == "belongs_to"
+            detail += " (fk: #{Introspectors::SchemaConventions.key_text(a[:foreign_key])})" if a[:foreign_key] && a[:type] == "belongs_to"
             detail += " [UNAVAILABLE: #{a[:unavailable]}]" if a[:unavailable]
             lines << detail
           end

data/lib/rails_ai_context/tools/get_partial_interface.rb

@@ -369,7 +369,21 @@ module RailsAiContext
 
           relative = file.sub("#{root}/", "")
 
-          content.each_line.with_index(1) do |line, line_num|
+          lines = content.lines
+          # Per call, not per line: `render(` and a call split over lines are
+          # one call whose arguments the line alone does not hold.
+          covered = 0
+          Introspectors::ViewTemplateIntrospector.render_calls(content).each do |at, args|
+            args = args.split("%>", 2).first
+            # A render inside another's arguments is already part of that call's site.
+            next if at < covered
+
+            covered = at + args.length
+            line_num = content[0...at].count("\n") + 1
+            line = "render #{args.gsub(/\s+/, " ").strip}"
+            spanned = lines[(line_num - 1)..(line_num - 1 + args.chomp.count("\n"))]
+            snippet = spanned.size > 1 ? spanned.join(" ").squish : lines[line_num - 1].strip
+
             matched_line = false
             search_patterns.each do |search_name|
               # Match render "partial_name" or render partial: "partial_name"
@@ -389,10 +403,10 @@ module RailsAiContext
                 file: relative,
                 line: line_num,
                 locals: locals_passed,
-                snippet: line.strip
+                snippet: snippet
               }
               matched_line = true
-              break # one match per line is enough
+              break # one match per call is enough
             end
 
             next if matched_line
@@ -408,7 +422,7 @@ module RailsAiContext
                 file: relative,
                 line: line_num,
                 locals: [],
-                snippet: line.strip
+                snippet: snippet
               }
               break
             end

data/lib/rails_ai_context/tools/get_routes.rb

@@ -75,26 +75,36 @@ module RailsAiContext
       # Routes in an engine's table are counted apart from the app's on both tiers. Booted
       # reads the engine's whole table; static reads what the app's route files draw into it.
       private_class_method def self.engine_routes_lines(engine_routes)
-        groups = Array(engine_routes)
-        return [] if groups.empty?
-
-        lines = [ "", "## Routes drawn into mounted engines" ]
-        groups.each do |group|
-          at = group[:mount] ? " at `#{group[:mount]}`" : " (not mounted by the app's routes)"
-          at += " (also #{group[:also_mounted_at].map { |path| "`#{path}`" }.join(', ')})" if group[:also_mounted_at]
+        unread, drawn = Array(engine_routes).partition { |group| group[:unavailable] }
+        lines = []
+        lines << "" << "## Routes drawn into mounted engines" if drawn.any?
+        drawn.each do |group|
           whole = group[:whole_table] ? " in the engine's whole table, gem-drawn ones included" : ""
           unexpanded = group[:dynamic_routes].to_i.positive? ? ", #{count_phrase(group[:dynamic_routes], "dynamic construct")} not expanded" : ""
-          lines << "- **#{group[:engine]}**#{at}: #{count_phrase(Array(group[:routes]).size, "route")}#{whole}#{unexpanded}, not in the count above"
+          lines << "- **#{group[:engine]}**#{mounted_at(group)}: #{count_phrase(Array(group[:routes]).size, "route")}#{whole}#{unexpanded}, not in the count above"
+        end
+        lines << "" << "## Mounted engines whose routes were not read" if unread.any?
+        unread.each do |group|
+          lines << "- **#{group[:engine]}**#{mounted_at(group)}: #{RailsAiContext::Confidence.unavailable(group[:unavailable])}"
         end
         lines
       end
 
+      private_class_method def self.mounted_at(group)
+        at = if group[:mount] then " at `#{group[:mount]}`"
+        elsif group[:mount_computed] then " at a path the routes compute"
+        else " (not mounted by the app's routes)"
+        end
+        at += " (also #{group[:also_mounted_at].map { |path| "`#{path}`" }.join(', ')})" if group[:also_mounted_at]
+        at
+      end
+
       # The routes a controller filter matches in the engines' tables, one
       # group per controller labelled with its engine, listed like the app's.
       private_class_method def self.engine_controller_groups(engine_routes, needles)
         Array(engine_routes).each_with_object({}) do |group, found|
           matches = Array(group[:routes]).select { |r| needles.any? { |n| path_segments_match?(r[:controller].to_s, n, tail: true) } }
-          where = group[:mount] ? "" : ", not mounted by the app's routes"
+          where = group[:mount] || group[:mount_computed] ? "" : ", not mounted by the app's routes"
           matches.group_by { |r| r[:controller] }.each do |ctrl, rows|
             found["#{ctrl} (in #{group[:engine]}'s table#{where})"] = rows
           end

data/lib/rails_ai_context/tools/get_schema.rb

@@ -77,9 +77,11 @@ module RailsAiContext
               # The key is the caller's own string when nothing matched, and
               # the declared names are table names: `OrderComments` and
               # `order_comments` are the same request.
-              if declared_not_connected(schema).include?(table_key.to_s.underscore)
+              declared = table_key.to_s.underscore
+              if declared_not_connected(schema).include?(declared)
                 return text_response(
-                  "Table '#{table_key.to_s.underscore}' is declared in db/schema.rb and missing from the connected database. " \
+                  "Table '#{declared}' is declared in db/schema.rb and missing from the connected database. " \
+                  "#{pending_for_table(schema, declared)}" \
                   "Run `rails db:migrate`, or pass `--no-boot` to read the declaration instead."
                 )
               end
@@ -87,7 +89,7 @@ module RailsAiContext
               return not_found_response("Table", table, tables.keys.sort,
                 recovery_tool: "Call rails_get_schema(detail:\"summary\") to see all tables")
             end
-            return json_response(table_data) if format == "json"
+            return json_response(table_data.except(:unread_calls)) if format == "json"
 
             output = format_table_markdown(table_key, table_data, models_data)
             # Cross-reference hint for AI: suggest next tool call
@@ -326,6 +328,19 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [], label: "models_for_table")
       end
 
+      # The pending migrations named after the table, or all of them when none
+      # is: a migration that adds a table is not always named for it.
+      private_class_method def self.pending_for_table(schema, table)
+        pending = Array(schema[:pending_migrations])
+        return "" if pending.empty?
+
+        named = pending.select { |m| m[:name].to_s.underscore.include?(table) }
+        named = pending if named.empty?
+        shown = named.first(5).map { |m| "#{m[:version]} #{m[:name]}".strip }.join(", ")
+        more = named.size > 5 ? " (+#{named.size - 5} more)" : ""
+        "Pending: #{shown}#{more}. "
+      end
+
       # The tables db/schema.rb declares that the connected database does not
       # have. Empty unless both sides are known, which is the booted tier
       # with a schema file to read.
@@ -390,7 +405,8 @@ module RailsAiContext
       # with :tables cut down to the page the same pagination produced for
       # markdown. `detail` still decides how many tables a page holds.
       private_class_method def self.json_page_response(schema, tables, names, models = {})
-        page = names.to_h { |name| [ name, tables[name] ] }
+        # unread_calls is the static reader's note to validate; the booted tier has none.
+        page = names.to_h { |name| [ name, tables[name].is_a?(Hash) ? tables[name].except(:unread_calls) : tables[name] ] }
         coverage = model_coverage(tables, models)
         json_response(schema.merge(tables: page, gem_owned_tables: coverage[:gems], tables_without_model_file: coverage[:unclaimed]))
       end
@@ -402,6 +418,8 @@ module RailsAiContext
       private_class_method def self.model_coverage(tables, models)
         unclaimed = tables.keys.sort.select { |name| models_for_table(name, models).empty? } - habtm_join_tables(models).to_a
         unclaimed -= declared_join_tables(models).to_a if unclaimed.any?
+        # A file the walk could not read claims no table, but it is still a model file.
+        unclaimed -= models.filter_map { |_, d| d[:table_name] || Introspectors::TableName.stem(d[:file]) if d.is_a?(Hash) && d[:error] && d[:file] }
         gems = gem_owned(unclaimed)
         { gems: gems, unclaimed: unclaimed - gems.values.flatten }
       end
@@ -469,7 +487,8 @@ module RailsAiContext
         if data[:foreign_keys]&.any?
           lines << "" << "### Foreign keys"
           data[:foreign_keys].each do |fk|
-            lines << "- `#{fk[:column]}` → `#{fk[:to_table]}.#{fk[:primary_key]}`"
+            lines << "- `#{RailsAiContext::Introspectors::SchemaConventions.key_text(fk[:column])}` → " \
+                     "`#{fk[:to_table]}.#{RailsAiContext::Introspectors::SchemaConventions.key_text(fk[:primary_key])}`"
           end
         end
 

data/lib/rails_ai_context/tools/get_service_pattern.rb

@@ -69,7 +69,9 @@ module RailsAiContext
       end
 
       private_class_method def self.format_single_service(service, service_files, service_dirs, root, lookup)
-        matches = match_service_files(service, service_files, service_dirs)
+        records = without_mixins(match_service_files(service, service_files, service_dirs)
+          .filter_map { |f| service_record(f, service_dirs, lookup) }, root)
+        matches = records.map { |r| r[:path] }
 
         if matches.size > 1
           # Paths are printed from the app root, not re-prefixed with
@@ -101,19 +103,20 @@ module RailsAiContext
         unless file
           # The constants the files declare, as the listing names them: the
           # camelized path spells Activitypub:: where Mastodon writes ActivityPub::.
-          available = service_files.filter_map { |f| (source = safe_read(f)) && name_and_superclass(source, f, service_dirs).first }.uniq
+          available = service_records(service_files, service_dirs, root, lookup).filter_map { |r| r[:class_name] }.uniq
           return not_found_response("Service", service, available.sort,
             recovery_tool: "Call rails_get_service_pattern(detail:\"summary\") to see all services")
         end
 
         return text_response("Service file too large to analyze.") if File.size(file) > max_file_size
 
-        source = safe_read(file)
+        record = records.find { |r| r[:path] == file }
+        source = record[:source]
         return text_response("Could not read service file.") unless source
 
         relative = file.sub("#{root}/", "")
         line_count = source.lines.size
-        class_name, = name_and_superclass(source, file, service_dirs)
+        class_name = record[:class_name]
 
         lines = [ "# #{class_name}", "" ]
         lines << "**File:** `#{relative}` (#{count_phrase(line_count, "line")})"
@@ -178,40 +181,56 @@ module RailsAiContext
         text_response(lines.join("\n"))
       end
 
-      private_class_method def self.format_service_listing(service_files, service_dirs, root, detail, lookup)
-        service_data = []
+      # The classes the listing counts before it sets the bases apart. The by-name
+      # lookup reads the same list, so it never answers what the listing leaves out.
+      private_class_method def self.service_records(service_files, service_dirs, root, lookup)
+        without_mixins(service_files.filter_map { |file| service_record(file, service_dirs, lookup) }, root)
+      end
 
-        service_files.each do |file|
-          source = safe_read(file)
-          next unless source
-          next if Introspectors::ServiceClasses.concern?(nil, source)
+      private_class_method def self.service_record(file, service_dirs, lookup)
+        source = safe_read(file)
+        # Kept unread so a by-name lookup can say the file is too large.
+        return { path: file } unless source
+        return if Introspectors::ServiceClasses.concern?(nil, source)
+
+        class_name, superclass = name_and_superclass(source, file, service_dirs)
+        return if Introspectors::ServiceClasses.mailer?(source, class_name, superclass, lookup)
 
-          class_name, superclass = name_and_superclass(source, file, service_dirs)
-          next if Introspectors::ServiceClasses.mailer?(source, class_name, superclass, lookup)
+        { path: file, source: source, class_name: class_name, superclass: superclass,
+          entryless: Introspectors::ServiceClasses.entryless_module?(source, class_name) }
+      end
 
+      # A module other classes mix in is a concern in all but directory, and
+      # the generated files' Services line leaves it out by the same rule.
+      private_class_method def self.without_mixins(records, root)
+        entryless = records.select { |r| r[:entryless] }.map { |r| r[:class_name] }
+        return records if entryless.empty?
+
+        mixins = Introspectors::ServiceClasses.mixed_in(root, entryless)
+        records.reject { |r| mixins.include?(r[:class_name]) }
+      end
+
+      private_class_method def self.format_service_listing(service_files, service_dirs, root, detail, lookup)
+        service_data = service_records(service_files, service_dirs, root, lookup).filter_map do |record|
+          next unless record[:source]
+
+          file, source = record.values_at(:path, :source)
           owned = owned_methods(source, constant_for(file, service_dirs))
-          public_methods = extract_public_methods(owned)
-          init_params = extract_initialize_params(owned)
 
-          service_data << {
+          {
             file: file.sub("#{root}/", ""),
-            class_name: class_name,
-            superclass: superclass,
+            class_name: record[:class_name],
+            superclass: record[:superclass],
             line_count: source.lines.size,
-            public_methods: public_methods,
-            init_params: init_params,
+            public_methods: extract_public_methods(owned),
+            init_params: extract_initialize_params(owned),
             class_method_call: owned.any? { |m| m[:scope] == :class && m[:name] == "call" },
             result_object: source.match?(/Result\.new|OpenStruct\.new|Struct\.new|\.success|\.failure/),
             active_interaction: Introspectors::Interaction.interaction?(source, lookup: lookup),
-            entryless: Introspectors::ServiceClasses.entryless_module?(source, class_name)
+            entryless: record[:entryless]
           }
         end
 
-        # A module other classes mix in is a concern in all but directory, and
-        # the generated files' Services line leaves it out by the same rule.
-        mixins = Introspectors::ServiceClasses.mixed_in(root, service_data.select { |s| s[:entryless] }.map { |s| s[:class_name] })
-        service_data = service_data.reject { |s| mixins.include?(s[:class_name]) }
-
         bases = base_class_names(service_data)
         service_data = service_data.reject { |s| bases.include?(s[:class_name]) }
         # A directory of base classes alone has no service anybody calls, and

data/lib/rails_ai_context/tools/get_test_info.rb

@@ -188,9 +188,11 @@ module RailsAiContext
         exercising = type == :controller ? exercising_tests(snake, candidates) : []
 
         contained = []
+        too_large = nil
         candidates.each do |rel|
           content, resolution = RailsAiContext::SafePath.read(rel, under: rails_app.root.to_s, max_size: max_test_file_size)
           contained << rel unless ESCAPING_REFUSALS.include?(resolution.refusal)
+          too_large ||= resolution if resolution.refusal == :too_large
           next unless content
 
           # Summary/standard: return just test names (saves 2000+ tokens vs full source)
@@ -203,6 +205,12 @@ module RailsAiContext
           return text_response(answer + exercising_section(exercising, "## Also exercised by"))
         end
 
+        if too_large
+          return text_response("# #{too_large.relative}\n\n_The test file exists but was not read: #{human_size(File.size(too_large.realpath))} is over " \
+                               "`max_test_file_size` (#{human_size(max_test_file_size)})._" +
+                               exercising_section(exercising, "## Also exercised by"))
+        end
+
         if exercising.any?
           return text_response("# Tests that exercise #{name}" + exercising_section(exercising, nil, names: true))
         end

data/lib/rails_ai_context/tools/migration_advisor.rb

@@ -573,7 +573,7 @@ module RailsAiContext
         end
 
         def postgresql_adapter?
-          current_adapter.match?(/postgres/i)
+          current_adapter.match?(/postg/i)
         end
       end
     end

data/lib/rails_ai_context/tools/query.rb

@@ -80,9 +80,7 @@ module RailsAiContext
         load_file | load_extension
       )\b/ix
 
-      # MySQL `SELECT ... INTO OUTFILE 'path'` / `INTO DUMPFILE 'path'`
-      # are caught by SELECT_INTO already, but make an explicit pattern so
-      # the error message is accurate.
+      # Checked before SELECT_INTO, which also matches, so the refusal names the disk write.
       BLOCKED_OUTPUT = /\bINTO\s+(OUTFILE|DUMPFILE)\b/i
 
       # Defense against the column-aliasing redaction bypass:
@@ -124,6 +122,9 @@ module RailsAiContext
       # with no READ ONLY transaction and no statement timeout.
       MYSQL_ADAPTER = /mysql|trilogy/i
 
+      # activerecord-postgis-adapter reports "PostGIS" for what is a PostgreSQL connection.
+      POSTGRES_ADAPTER = /postg/i
+
       # SHOW/DESCRIBE/EXPLAIN return schema metadata (a table's column list,
       # an EXPLAIN plan), never application data rows. Two consequences:
       #   1. They're inherently bounded - appending `LIMIT n` to them is
@@ -204,7 +205,7 @@ module RailsAiContext
       rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::NoDatabaseError => e
         text_response("Database unavailable: #{clean_error_message(e.message)}\n\n**Troubleshooting:**\n- Check `config/database.yml` for correct host/port/credentials\n- Try `RAILS_ENV=test` if the development DB is remote\n- Run `bin/rails db:create` if the database doesn't exist yet")
       rescue ActiveRecord::StatementInvalid => e
-        if e.message.match?(/timeout|statement_timeout|MAX_EXECUTION_TIME/i)
+        if e.message.match?(/timeout|statement_timeout|MAX_EXECUTION_TIME|maximum statement execution time exceeded/i)
           text_response("Query exceeded #{config.query_timeout} second timeout. Simplify the query or add indexes.")
         # Only a missing DATABASE. Postgres words a missing column and a
         # missing table the same way ("... does not exist"), and matching
@@ -262,8 +263,8 @@ module RailsAiContext
         return [ false, "Blocked: multiple statements (no semicolons)" ] if cleaned.match?(MULTI_STATEMENT)
         return [ false, "Blocked: FOR UPDATE/SHARE clause" ] if cleaned.match?(BLOCKED_CLAUSES)
         return [ false, "Blocked: sensitive SHOW command" ] if cleaned.match?(BLOCKED_SHOWS)
-        return [ false, "Blocked: SELECT INTO creates a table" ] if cleaned.match?(SELECT_INTO)
         return [ false, "Blocked: SELECT INTO OUTFILE / DUMPFILE writes to disk" ] if cleaned.match?(BLOCKED_OUTPUT)
+        return [ false, "Blocked: SELECT INTO creates a table" ] if cleaned.match?(SELECT_INTO)
 
         # Block database functions that give a filesystem/network primitive.
         # pg_read_file, lo_import, dblink, LOAD_FILE, load_extension, etc.
@@ -335,7 +336,7 @@ module RailsAiContext
       # the plan, so `explain: true` must not hold a connection past query_timeout.
       private_class_method def self.run_guarded(conn, adapter, sql, timeout)
         case adapter
-        when /postgresql/
+        when POSTGRES_ADAPTER
           execute_postgresql(conn, sql, timeout)
         when MYSQL_ADAPTER
           execute_mysql(conn, sql, timeout)
@@ -418,7 +419,7 @@ module RailsAiContext
         adapter = conn.adapter_name.downcase
 
         explain_sql, parser = case adapter
-        when /postgresql/
+        when POSTGRES_ADAPTER
           [ "EXPLAIN (FORMAT JSON, ANALYZE) #{sql}", :parse_pg_explain ]
         when MYSQL_ADAPTER
           # MySQL 8.3+ and 9.x default explain_format to TREE, which

data/lib/rails_ai_context/tools/runtime_info.rb

@@ -93,7 +93,7 @@ module RailsAiContext
           conn = ActiveRecord::Base.connection
           adapter = conn.adapter_name.downcase
           lines = [ "## Database", "" ]
-          lines << "**Adapter:** #{conn.adapter_name}"
+          lines << "**Adapter:** #{SchemaAdapter.display(conn.adapter_name)}"
 
           # Table sizes
           sizes = gather_table_sizes(conn, adapter)
@@ -101,12 +101,13 @@ module RailsAiContext
             lines << "" << "### Table Sizes"
             lines << "| Table | Size |"
             lines << "|-------|------|"
-            sizes.first(RailsAiContext::DetailLevel.summary?(detail) ? 5 : 30).each do |row|
+            shown = RailsAiContext::DetailLevel.summary?(detail) ? 5 : 30
+            sizes.first(shown).each do |row|
               lines << "| #{row[:name]} | #{human_size(row[:bytes])} |"
             end
             total = sizes.sum { |r| r[:bytes] }
             lines << "| **Total** | **#{human_size(total)}** |"
-            lines << "_#{count_phrase(sizes.size - 30, "more table")}..._" if detail != "summary" && sizes.size > 30
+            lines << "_#{count_phrase(sizes.size - shown, "more table")}..._" if sizes.size > shown
           end
 
           # Pending migrations
@@ -129,8 +130,9 @@ module RailsAiContext
               if unused.any?
                 lines << "**Unused indexes (0 scans):**"
                 unused.first(10).each { |i| lines << "- `#{i[:index]}` on `#{i[:table]}`" }
+                lines << "_#{count_phrase(unused.size - 10, "more unused index", plural: "more unused indexes")}..._" if unused.size > 10
               end
-              hot = index_usage.sort_by { |i| -(i[:scans] || 0) }.first(5)
+              hot = index_usage.sort_by { |i| [ -i[:scans].to_i, i[:table].to_s, i[:index].to_s ] }.first(5)
               lines << "" << "**Most used indexes:**"
               hot.each { |i| lines << "- `#{i[:index]}` on `#{i[:table]}` - #{count_phrase(i[:scans], "scan")}" }
             end
@@ -152,12 +154,14 @@ module RailsAiContext
         # table sizes for every Trilogy app.
         MYSQL_ADAPTER = /mysql|trilogy/i
 
+        # activerecord-postgis-adapter reports "PostGIS" for what is a PostgreSQL connection.
+        POSTGRES_ADAPTER = /postg/i
+
         def gather_table_sizes(conn, adapter)
           rows =
             case adapter
-            when /postgresql/
-              sql = "SELECT relname AS name, pg_total_relation_size(relid) AS bytes FROM pg_stat_user_tables ORDER BY bytes DESC"
-              conn.select_all(sql).map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
+            when POSTGRES_ADAPTER
+              Introspectors::PgPartitions.table_bytes(conn).sort_by { |r| [ -r[:bytes], r[:name] ] }
             when MYSQL_ADAPTER
               sql = "SELECT table_name AS name, (data_length + index_length) AS bytes FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = DATABASE() ORDER BY bytes DESC"
               conn.select_all(sql).map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
@@ -204,9 +208,8 @@ module RailsAiContext
 
         def gather_index_usage(conn, adapter)
           case adapter
-          when /postgresql/
-            sql = "SELECT relname AS table, indexrelname AS index, idx_scan AS scans FROM pg_stat_user_indexes ORDER BY idx_scan ASC"
-            conn.select_all(sql).map { |r| { table: r["table"], index: r["index"], scans: r["scans"].to_i } }
+          when POSTGRES_ADAPTER
+            Introspectors::PgPartitions.index_stats(conn).sort_by { |i| [ i[:scans], i[:table], i[:index] ] }
           else
             nil
           end