rails-ai-context 5.35.1 → 5.35.2

data/lib/rails_ai_context/introspectors/multi_database_introspector.rb

@@ -19,11 +19,20 @@ module RailsAiContext
           sharding: detect_sharding,
           model_connections: detect_model_connections,
           multi_db: dbs.size > 1
-        }.merge({ example_adapters: example_adapters, primary_name: primary_name }.compact)
+        }.merge(from_configuration)
+      end
+
+      # What the section says of each database by name, read from configuration alone.
+      def listing
+        { databases: discover_databases }.merge(from_configuration)
       end
 
       private
 
+      def from_configuration
+        { example_adapters: example_adapters, primary_name: primary_name }.compact
+      end
+
       # The primary's database.yml name where it is not "primary": a generated file tells it from a database that is.
       def primary_name
         name = RailsAiContext::AppDatabases.for(root).primary&.name.to_s

data/lib/rails_ai_context/introspectors/performance_introspector.rb

@@ -75,7 +75,6 @@ module RailsAiContext
           foreign_keys: tables.values.flat_map { |table| Array(table[:foreign_keys]).map { |fk| { from: fk[:from_table], to: fk[:to_table], column: fk[:column] } } } }
       end
 
-      # Why a database with no dump on disk has none.
       def no_dump_reason(db)
         return "its database.yml entry turns `database_tasks` off, so Rails writes it no dump" unless db.tasks
         return "its database.yml entry turns `schema_dump` off, so Rails writes it no dump" unless db.settings["schema_dump"]

data/lib/rails_ai_context/payload.rb

@@ -135,18 +135,28 @@ module RailsAiContext
       words ? " (#{words})" : ""
     end
 
+    # The multi_database section. A payload that holds none (a preset without it) gets the same list
+    # from the app databases, so no mark or name depends on the preset.
+    def multi_database(context)
+      section(context, :multi_database) || Introspectors::MultiDatabaseIntrospector.new(RailsAiContext.default_app).listing
+    end
+
+    def databases(context)
+      Array(multi_database(context)[:databases]).grep(Hash)
+    end
+
     def named_scope_words(context, name)
-      scope_words(list(context, :multi_database, :databases).grep(Hash).find { |database| database[:name].to_s == name.to_s })
+      scope_words(databases(context).find { |database| database[:name].to_s == name.to_s })
     end
 
     # What a generated file calls the primary: its own name where another database is the one named primary.
     def primary_label(context)
-      name = section(context, :multi_database)&.dig(:primary_name)
+      name = multi_database(context)[:primary_name]
       name && database_named?(context, "primary") ? name.to_s : "primary"
     end
 
     def database_named?(context, name)
-      list(context, :multi_database, :databases).grep(Hash).any? { |database| database[:name].to_s == name }
+      databases(context).any? { |database| database[:name].to_s == name }
     end
 
     # The mark for a database known by its database.yml name.

data/lib/rails_ai_context/secret_columns.rb

@@ -36,10 +36,11 @@ module RailsAiContext
     # A wildcard in a select list. `count(*)` reads no column, so it is left out.
     WILDCARD = /(?:\b(?:SELECT|DISTINCT|ALL)\b|[,.])\s*\*/i
 
-    # A name as a statement writes it before a dot: in backticks, double quotes or brackets, or bare.
-    QUOTED_NAME = /`(?:``|[^`])+`|"(?:""|[^"])+"|\[[^\]]+\]/
+    # A name before a dot, matched in reversed text from the dot backward: bare, or in backticks or double quotes
+    # with the quote doubled inside. A schema name on MySQL, MariaDB or PostgreSQL is 64 characters at most.
+    NAME_END = /\.(?=\s*(?:[\p{Word}$`"]|[^\x00-\x7F]))/
     BARE_NAME = /(?:[\p{Word}$]|[^\x00-\x7F])+/
-    CLOSERS = { "`" => "`", '"' => '"', "[" => "]" }.freeze
+    QUOTED_NAME = /`((?>(?:``|[^`]){1,64}))`(?!`)|"((?>(?:""|[^"]){1,64}))"(?!")/
 
     # How many times the schemas a statement and the view definitions name are followed into more view definitions.
     ROUNDS = 3
@@ -60,9 +61,8 @@ module RailsAiContext
       statement.to_s.strip.empty? ? secrets : secrets.cover(statement)
     end
 
-    # A name or a statement as the databases compare names: case folded. MySQL reads a dotted capital I
-    # as i, where Ruby's downcase keeps the dot as a combining mark. Runs of spaces are squeezed in both,
-    # so a name is found in text whether or not the text was squeezed before it came here.
+    # A name or a statement as the databases compare names: case folded, a dotted capital I read as i (MySQL does,
+    # Ruby's downcase keeps the dot), and runs of spaces squeezed, so a name is found in text squeezed or not.
     def self.fold(text)
       text.to_s.downcase.delete("\u0307").squeeze(" ")
     end
@@ -70,7 +70,7 @@ module RailsAiContext
     # Matches the name as a whole identifier in folded text, whatever characters it holds and however it is quoted.
     def self.identifier(name)
       name = fold(name)
-      spellings = [ name, name.gsub('"', '""'), name.gsub("`", "``") ].uniq.map { |spelling| Regexp.escape(spelling) }
+      spellings = [ name, name.gsub('"', '""'), name.gsub("`", "``"), name.gsub("'", "''") ].uniq.map { |spelling| Regexp.escape(spelling) }
       /(?<!\p{Word})(?:#{spellings.join("|")})(?!\p{Word})/
     end
 
@@ -171,6 +171,7 @@ module RailsAiContext
       @index_tables = {}
       @asked = Set.new
       @read = []
+      @spelled = {}
       learn(relations: relations, views: views, traced_views: traced_views, generated: generated, index_tables: index_tables)
     end
 
@@ -182,8 +183,7 @@ module RailsAiContext
       reach(SqlGate.comment_free(statement, DatabaseFamily.of(@connection)))
     end
 
-    # Reads the schemas given and the ones the text names, then the ones the definitions of the views it names
-    # name, and so on through the views those name, ROUNDS reads deep. A view no text names is not followed.
+    # Reads the schemas given and those the text names, then follows the views the text names ROUNDS definitions deep.
     # @raise [Unreadable] when a view the text names leads deeper, or a schema's columns cannot be read
     def reach(text, schemas = [])
       return self unless @connection
@@ -253,12 +253,12 @@ module RailsAiContext
     # column outside the statement, where no check on the statement reads it.
     def refused_view_in(text)
       down = self.class.fold(text)
-      @refused_views.find { |view, _why| names?(down, view) }
+      view, why = @refused_views.find { |name, _why| names?(down, name) }
+      [ spelled(view), why ] if view
     end
 
-    # Why the view at exactly this place is refused, or nil. PostgreSQL's plan names a relation as `schema.relation`,
-    # so a table is not taken for a view of its name in another schema. Views known by name alone (their
-    # definitions could not be read) are told by the bare name.
+    # Why the view at exactly this place is refused, or nil. The plan names a relation as `schema.relation`, so a table
+    # is not taken for a view of its name in another schema; a view with no definition read is told by its bare name.
     def placed_view_refusal(relation, name)
       placed, bare = self.class.fold(relation), self.class.fold(name)
       return @refused_views[placed] if @views&.key?(placed)
@@ -276,13 +276,15 @@ module RailsAiContext
     # table, and a virtual table or its vocabulary when the virtual table holds a secret column.
     def unread_table_in(text)
       down = self.class.fold(text)
-      @unread_tables.find { |table, _why| names?(down, table) }
+      table, why = @unread_tables.find { |name, _why| names?(down, name) }
+      [ spelled(table), why ] if table
     end
 
     # The first relation holding a secret column that the statement's text names, or nil.
     def relation_named_in(text)
       down = self.class.fold(text)
-      @by_relation.each_key.find { |relation| names?(down, relation) }
+      relation = @by_relation.each_key.find { |name| names?(down, name) }
+      relation && spelled(relation)
     end
 
     # The first secret name the statement's text names, or nil. Case-insensitive
@@ -306,19 +308,16 @@ module RailsAiContext
 
     private
 
-    # Every name that stands before a dot: a schema, a table or an alias. One pass over the text, since a
-    # regexp that finds them is quadratic on a Ruby with no match cache; an opener with no closer is no name.
+    # Every name that stands before a dot, read backward from the dot, so a quote character inside a string before it
+    # changes nothing. A name in brackets is not read: SQLite reads every schema, and the gate refuses a bracket on MySQL.
     def dotted_names(text)
-      scanner = StringScanner.new(text)
-      bytes = text.b
-      last = CLOSERS.transform_values { |closer| bytes.rindex(closer) || -1 }
+      scanner = StringScanner.new(text.reverse)
       names = []
-      until scanner.eos?
-        quoted = last.fetch(scanner.peek(1), -1) > scanner.pos ? scanner.scan(QUOTED_NAME) : nil
-        name = quoted ? quoted[1..-2] : scanner.scan(BARE_NAME)
-        next scanner.getch unless name
-
-        names << name.gsub(/([`"])\1/, '\1') if scanner.match?(/\s*\./)
+      while scanner.skip_until(NAME_END)
+        scanner.skip(/\s+/)
+        if (bare = scanner.check(BARE_NAME)) then names << bare.reverse
+        elsif scanner.check(QUOTED_NAME) then names << (scanner[1]&.gsub("``", "`") || scanner[2].gsub('""', '"')).reverse
+        end
       end
       names
     end
@@ -344,12 +343,18 @@ module RailsAiContext
     def too_deep(found, followed, family)
       found = found.map { |schema| self.class.fold(schema) }
       view = followed.find { |name, _start| (dotted_names(self.class.fold(@views[name])) & found).any? }&.last
-      Unreadable.new("The view `#{view}` leads through more #{family.postgresql? ? "schemas" : "databases"} than rails_query follows " \
-        "(#{ROUNDS} rounds), so the secret columns it could read cannot be told and no statement that names it runs.")
+      Unreadable.new("The view `#{spelled(view)}` leads through more #{family.postgresql? ? "schemas" : "databases"} than rails_query follows, " \
+        "so the secret columns it could read cannot be told and no statement that names it runs.")
+    end
+
+    # The name as the database spells it, for a sentence: the rule itself holds every name folded.
+    def spelled(name)
+      @spelled.fetch(name, name)
     end
 
     def learn(relations:, views: nil, traced_views: [], generated: {}, index_tables: {})
       fold = self.class.method(:fold)
+      [ relations, views, index_tables ].each { |named| named&.each_key { |name| @spelled[fold.call(name)] ||= name.to_s } }
       relations.each { |relation, names| @columns[fold.call(relation)].concat(Array(names).map(&fold)) }
       generated.each do |relation, expressions|
         @columns[fold.call(relation)].concat(expressions.keys.map(&fold))
@@ -414,7 +419,7 @@ module RailsAiContext
         end
         return refused if nested.empty?
 
-        nested.each { |view, inner| refused[view] = "it reads the view `#{inner}`: #{refused[inner]}" }
+        nested.each { |view, inner| refused[view] = "it reads the view `#{spelled(inner)}`: #{refused[inner]}" }
       end
     end
 
@@ -438,23 +443,44 @@ module RailsAiContext
       end
     end
 
-    # The value of a full-text table's `content=` option, quoted or bare.
-    CONTENT_OPTION = /\bcontent\s*=\s*("(?:""|[^"])*"|'(?:''|[^'])*'|`(?:``|[^`])*`|\[[^\]]*\]|[^\s,)]+)/i
+    # A name or a string in any of the four quotings SQLite reads.
+    SQLITE_QUOTED = /"(?:""|[^"])*"|'(?:''|[^'])*'|`(?:``|[^`])*`|\[[^\]]*\]/
+
+    # One argument of a virtual table's module: up to the next comma outside quotes, brackets and parentheses.
+    MODULE_ARGUMENT = /(?:#{SQLITE_QUOTED}|\([^()]*\)|[^,])+/
 
-    # virtual table => why it is not read, for each one whose definition names a refused view or a table that
-    # is not read: its rows, or its words, are theirs. A definition names a relation in its `content=` option
-    # and, for a vocabulary, as its table: any other word of it is a column or an option of its own.
+    # virtual table => why it is not read, for each one built on a refused view or on a table that is not read:
+    # its rows, or its words, are theirs.
     def built_on_unread(index_tables)
       index_tables.each_with_object({}) do |(table, (kind, owner, definition)), built|
         table = self.class.fold(table)
         next if definition.nil? || @unread_tables.key?(table)
 
-        down = self.class.fold(kind == :vocabulary ? owner : definition.scan(CONTENT_OPTION).join(" "))
+        down = self.class.fold("#{owner if kind == :vocabulary} #{relation_words(table, definition)}")
         view, why = @refused_views.find { |name, _why| name != table && names?(down, name) }
         other = @unread_tables.keys.find { |name| name != table && names?(down, name) } unless view
-        built[table] = "its definition names the view `#{view}`, which is not queried: #{why}" if view
-        built[table] = "its definition names `#{other}`, which is not read" if other
+        built[table] = "its definition names the view `#{spelled(view)}`, which is not queried: #{why}" if view
+        built[table] = "its definition names `#{spelled(other)}`, which is not read" if other
+      end
+    end
+
+    # The name an argument of a virtual table's module opens with: one quoted name whole, or its first word.
+    LEADING_NAME = /\A\s*(?:#{SQLITE_QUOTED}|[^\s"'`\[]+)/
+
+    # What a virtual table's definition can name a relation with: its module, and every argument but the columns a
+    # full-text table declares (a column named like a view is no view). An argument with `=` is an option, kept whole.
+    def relation_words(table, definition)
+      mod, arguments = definition.match(/\A\s*USING\s+([^\s(]+)\s*(?:\((.*)\))?\s*\z/mi)&.captures
+      return definition unless mod
+
+      mod_name = mod.delete(%q("'`[]))
+      columns = mod_name.match?(/\Afts[345]\z/i) ? @columns[table] : []
+      named = arguments.to_s.scan(MODULE_ARGUMENT).reject do |argument|
+        !argument.include?("=") && columns.include?(self.class.fold(argument[LEADING_NAME].to_s.delete(%q("'`[])).strip))
       end
+      # A vocabulary's last argument is its type (row, col or instance), which SQLite reads as no relation.
+      named.pop if mod_name.casecmp?("fts5vocab") && named.size > 1
+      [ mod, *named ].join(" ")
     end
 
     def refusal_of(definition)
@@ -463,9 +489,9 @@ module RailsAiContext
       elsif (column = named_in(definition))
         "its definition names the secret column `#{column}`"
       elsif (table = @unread_tables.keys.find { |name| names?(definition, name) })
-        "its definition reads `#{table}`, which is not read"
+        "its definition names `#{spelled(table)}`, which is not read"
       elsif definition.match?(WILDCARD) && (relation = @by_relation.keys.find { |name| names?(definition, name) })
-        "its definition has a wildcard and names `#{relation}`, which holds the secret column `#{@by_relation[relation].first}`"
+        "its definition has a wildcard and names `#{spelled(relation)}`, which holds the secret column `#{@by_relation[relation].first}`"
       end
     end
 

data/lib/rails_ai_context/serializers/markdown_serializer.rb

@@ -512,7 +512,7 @@ module RailsAiContext
         end
 
         if data[:recent]&.any?
-          lines << "### Recent Migrations#{": primary" if secondary.any?}"
+          lines << "### Recent Migrations#{": #{Payload.primary_label(context)}" if secondary.any?}"
           data[:recent].each do |m|
             actions = m[:actions]&.any? ? " (#{m[:actions].join(', ')})" : ""
             lines << "- `#{m[:version]}` #{m[:name]}#{actions}"

data/lib/rails_ai_context/sql_gate.rb

@@ -38,8 +38,8 @@ module RailsAiContext
       end
     end
 
-    # The checks read a megabyte in two seconds at the slowest (a nest of parentheses, a run of dollar signs), and
-    # the longest statement written by hand is far under it: 100,000 ids in an IN list are 700 KB.
+    # The longest statement written by hand is far under it: 100,000 ids in an IN list are 700 KB. The checks on a
+    # statement's text have text_timeout seconds to read one.
     MAX_BYTES = 1_000_000
 
     # The text checks ran past the time they have.
@@ -64,7 +64,7 @@ module RailsAiContext
     # refused by the CREATE keyword - SHOW CREATE USER prints credential hashes.
     SHOW_CREATE_DEFINITION = /\A\s*SHOW\s+CREATE\s+(?:TABLE|VIEW)\b/i
     BLOCKED_CLAUSES  = /\bFOR\s+(?:UPDATE|SHARE|NO\s+KEY\s+UPDATE|KEY\s+SHARE)\b|\bLOCK\s+IN\s+SHARE\s+MODE\b/i
-    # The lists below hold each name under the family that has it, so a name is refused where it can be read.
+    # A list keyed by family holds each name under the family that has it, so a name is refused where it can be read.
 
     # Other sessions' statements, replication hosts and users, and the row data a log holds.
     BLOCKED_SHOWS = { mysql: /\bSHOW\s+(?:(?:FULL|ALL)\s+)?(?:GRANTS|PROCESSLIST|BINLOG|BINARY|RELAYLOG|SLAVES?|MASTER|REPLICAS?|ENGINE|
@@ -161,6 +161,10 @@ module RailsAiContext
       master_pos_wait | source_pos_wait
     )\s*\(/ix }.freeze
 
+    # A value either one sets stays on the pooled connection, in or out of a read-only transaction.
+    VARIABLE_ASSIGNMENT = { mysql: /:=/ }.freeze
+    SETS_LAST_INSERT_ID = { mysql: /\blast_insert_id\s*\(\s*[^\s)]/i }.freeze
+
     # VOLATILE built-ins that only read: pg_proc marks a reader of live server
     # state VOLATILE too. Any other VOLATILE function in the plan is refused.
     PG_VOLATILE_ALLOWLIST = %w[
@@ -251,9 +255,8 @@ module RailsAiContext
       end
     end
 
-    # family decides the lexing and whether the plan checks run. budget is the seconds the reads the
-    # gate sends (the plan, the pg_proc lookup) share with the caller's other reads. text_timeout is the seconds
-    # the checks on the statement's text have to themselves.
+    # budget: the seconds the reads the gate sends (the plan, the catalog lookups) share with the caller's other reads.
+    # text_timeout: the seconds the checks on the statement's text have to themselves.
     def initialize(family:, secrets:, connection:, budget:, text_timeout: RailsAiContext.configuration.query_timeout)
       @text_timeout = text_timeout
       @family = family
@@ -321,9 +324,16 @@ module RailsAiContext
       end
     end
 
-    # The comment that opens where the scanner stands, as the family reads it, or nil.
+    # Skips the comment that opens where the scanner stands, as the family reads it. One that never closes runs to the end.
+    # @return [Boolean] whether one opened there
     def self.comment(scanner, family)
-      scanner.scan(/\/\*.*?(?:\*\/|\z)/m) || scanner.scan(family.line_comment)
+      return !scanner.skip(family.line_comment).nil? unless scanner.skip(/\/\*/)
+
+      depth = 1
+      marks = family.nested_comments? ? /\/\*|\*\// : /\*\//
+      depth += scanner.matched == "/*" ? 1 : -1 while depth.positive? && scanner.skip_until(marks)
+      scanner.terminate if depth.positive?
+      true
     end
 
     private
@@ -372,6 +382,11 @@ module RailsAiContext
       # file functions stay on the raw text: no read-only transaction stops them.
       masked = mask_quoted(cleaned)
       return "Blocked: multiple statements (no semicolons)" if masked.match?(MULTI_STATEMENT)
+      # MariaDB in its MSSQL mode reads [name] as a quoted name, and no statement of this family holds a bracket otherwise.
+      if @family.mysql? && masked.include?("[")
+        return "Blocked: a `[` outside a string or a quoted name is not run. MariaDB reads it as the start of a quoted name when the " \
+          "session's sql_mode holds MSSQL, and rails_query does not read the session's mode. Quote a name in backticks."
+      end
       # PostgreSQL's read-only transaction refuses a locking read, so a literal there is data.
       # MySQL's runs FOR SHARE and LOCK IN SHARE MODE, so there the raw text decides.
       locking = @family.refuses_locking_reads? ? masked : cleaned
@@ -388,7 +403,11 @@ module RailsAiContext
       return "Blocked: SELECT INTO OUTFILE / DUMPFILE writes to disk" if cleaned.match?(BLOCKED_OUTPUT)
       # No second statement is left by here, so an INTO after a SELECT belongs to it.
       select = masked.index(/\bSELECT\b/i)
-      return "Blocked: SELECT INTO creates a table" if select && masked.rindex(/\bINTO\b/i).to_i > select
+      if select && masked.rindex(/\bINTO\b/i).to_i > select
+        # After a WITH clause the INTO can be a write's own.
+        write = masked[/\b(?:INSERT|MERGE|REPLACE(?!\s*\())\b(?=[^;]*\bINTO\b)/i]
+        return write ? "Blocked: contains #{write}" : "Blocked: SELECT INTO creates a table"
+      end
 
       if (m = listed(BLOCKED_FUNCTIONS, cleaned))
         return "Blocked: dangerous function #{m[0]} (filesystem/network primitive)"
@@ -428,6 +447,14 @@ module RailsAiContext
         return "Blocked: session function #{m[0].sub(/\s*\(\z/, "")} leaves state (a named lock) on the pooled " \
           "connection after the query returns. rails_query will not run it."
       end
+      if listed(VARIABLE_ASSIGNMENT, masked)
+        return "Blocked: a user variable assignment (`:=`) is not run. It leaves a value on the pooled connection after the query " \
+          "returns, which a read-only transaction does not stop."
+      end
+      if listed(SETS_LAST_INSERT_ID, cleaned)
+        return "Blocked: LAST_INSERT_ID with an argument is not run. It sets a value that stays on the pooled connection after the " \
+          "query returns, which a read-only transaction does not stop. LAST_INSERT_ID() with no argument runs."
+      end
 
       tokens = tokens(cleaned)
       if renaming_alias_list?(tokens)
@@ -590,8 +617,8 @@ module RailsAiContext
           "A model declares `#{offending}` with `encrypts`, so config.query_allowed_columns does not release it."
         end
       else
-        "#{"#{reads}. " if source}If `#{offending}` is not secret in your app, add \"#{offending}\" to " \
-          "config.query_allowed_columns in an initializer."
+        "#{"#{reads}. " if source}If `#{offending}` is not secret in your app, add \"#{offending}\" to query_allowed_columns in " \
+          ".rails-ai-context.yml (or in config/initializers/rails_ai_context.rb where the app bundles the gem)."
       end
       "Blocked: query references secret column `#{offending}`. " \
         "Name the columns you need; `#{offending}` is secret and never " \
@@ -773,9 +800,8 @@ module RailsAiContext
       end
     end
 
-    # :star for a select-list wildcard inside parentheses, :table for `TABLE t` there on a family that has the
-    # statement, :in for SQLite's `x IN t` anywhere, else nil. `count(*)` reads no column and EXISTS returns
-    # none, so both are left alone.
+    # :star for a select-list wildcard inside parentheses, :table for `TABLE t` there off SQLite, :in for SQLite's
+    # `x IN t` anywhere, else nil. `count(*)` reads no column and EXISTS returns none, so both are left alone.
     def subquery_wildcard(tokens)
       enclosing = []
       tokens.each_with_index do |token, i|
@@ -824,6 +850,8 @@ module RailsAiContext
         outputs.concat(Array(node["Output"]).map { |e| e.to_s.gsub(PLAN_LITERAL, "''") })
         PLAN_COND_KEYS.each { |k| conds.concat(Array(node[k]).map { |e| e.to_s.gsub(PLAN_LITERAL, "''") }) }
       end
+      foreign = plan.nodes.select { |node| node["Remote SQL"] }
+      conds.concat(foreign.map { |node| remote_uses(node) }, local_names(foreign))
       # EXPLAIN prints no row of a VALUES list and no LIMIT, so the functions the text names are read too.
       called = function_names(raw.map { |expr| expr.gsub(PLAN_LITERAL, "''") } + [ mask_sql_literals(text) ])
 
@@ -863,6 +891,32 @@ module RailsAiContext
       end
     end
 
+    # What the statement a foreign scan sends does with a column past fetching it: its joins, conditions and sorts.
+    # GROUP BY names a key by its place in the select list, so a grouped statement is read whole.
+    def remote_uses(node)
+      remote = node["Remote SQL"].to_s.gsub(PLAN_LITERAL, "''")
+      past_select = remote.sub(/\ASELECT\b.*?\bFROM\b/m, "")
+      past_select.match?(/\bGROUP\s+BY\b/i) ? remote : past_select
+    end
+
+    # The foreign columns a remote statement uses under the name their column_name option gives them, by their own
+    # names. A join or an aggregate the remote server runs names its tables under "Relations".
+    def local_names(foreign)
+      return [] if foreign.empty?
+
+      renamed = @budget.spend do |left|
+        @family.bounded(@connection, timeout: left) do
+          @connection.select_rows(
+            "SELECT c.relname, a.attname, o.option_value FROM pg_attribute a JOIN pg_class c ON c.oid = a.attrelid " \
+            "CROSS JOIN LATERAL pg_options_to_table(a.attfdwoptions) o WHERE o.option_name = 'column_name' AND NOT a.attisdropped"
+          )
+        end
+      end
+      renamed.filter_map do |table, local, far|
+        local if foreign.any? { |node| names?(node.values_at("Relation Name", "Relations").map(&:to_s), table) && names?([ remote_uses(node) ], far) }
+      end
+    end
+
     # A secret name the text check passed as a literal runs only when a plan cleared the checks,
     # so the plan backs a masker that a quote trick fooled.
     def unvouched_literal_refusal(text, plan)

data/lib/rails_ai_context/tools/get_context.rb

@@ -167,7 +167,7 @@ module RailsAiContext
         return nil if RailsAiContext::Introspectors::ActionSource.unlisted_action(rails_app.root, name, action.to_s,
                                                                                  file: Payload.controller_file(ctx, name), controllers: controllers)
 
-        "Action '#{echo_input(action)}' not found in #{name}. Available: #{actions.join(', ')}"
+        GetControllers.missing_action_message(name, action, actions)
       end
 
       # The templates for a controller, read from the directory Rails would
@@ -354,7 +354,7 @@ module RailsAiContext
         analyze_result = compose(AnalyzeFeature, feature: feature_name)
         parts = [ response_text(analyze_result) ]
         related = []
-        named = []
+        matched_models = []
 
         # Enrich with schema columns for matching models
         ctx = begin; cached_context; rescue; nil; end
@@ -364,7 +364,7 @@ module RailsAiContext
 
           models.each_key do |model_name|
             next unless model_name.downcase.include?(feature_name.downcase)
-            named << model_name
+            matched_models << model_name
             table_name = models[model_name][:table_name]
             next unless table_name
             matched_tables << table_name
@@ -396,7 +396,7 @@ module RailsAiContext
         return text unless text.empty? && !own_served?(AnalyzeFeature)
 
         # With rails_analyze_feature off, only model and controller names were matched.
-        return "The model names that hold '#{echo_input(feature_name)}': #{named.sort.join(', ')}." if named.any?
+        return "The model names that hold '#{echo_input(feature_name)}': #{matched_models.sort.join(', ')}." if matched_models.any?
 
         "No matches found for '#{echo_input(feature_name)}'. No model or controller name holds this keyword.#{AnalyzeFeature.model_names_hint(ctx)}"
       rescue => e

data/lib/rails_ai_context/tools/get_controllers.rb

@@ -287,6 +287,10 @@ module RailsAiContext
         end
       end
 
+      def self.missing_action_message(controller_name, action_name, actions)
+        "Action '#{echo_input(action_name)}' not found in #{controller_name}. Available: #{actions.join(', ')}"
+      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]]
@@ -304,7 +308,7 @@ module RailsAiContext
           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(', ')}")
+            return empty_response(missing_action_message(controller_name, action_name, actions))
           end
 
           action_name = unlisted[:name]

data/lib/rails_ai_context/tools/onboard.rb

@@ -187,13 +187,10 @@ module RailsAiContext
           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:, unread: }, the adapter nil when database.yml does not say,
-        # `unread` true for a dump that could not be read, whose table count is then no count.
+        # The app's own databases besides the primary, as its schema dumps declare them. The adapter is nil when
+        # database.yml does not say; `unread` marks a dump that could not be read, whose table count is no count.
         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 ] }
+          configured = Payload.databases(ctx).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, unread: db[:unread] }

data/lib/rails_ai_context/tools/query.rb

@@ -242,7 +242,7 @@ module RailsAiContext
         else
           "the row limit of #{cap}; pass limit: up to 1000 to see more"
         end
-        note = "#{cap} rows shown; the query returned more (#{detail})."
+        note = "#{count_phrase(cap, "row")} shown; the query returned more (#{detail})."
         format == "csv" ? "\n\n#{note}" : "\n\n_#{note}_"
       end
 

data/lib/rails_ai_context/tools/runtime_info.rb

@@ -123,7 +123,9 @@ module RailsAiContext
           end
 
           sizes = gather_table_sizes(conn, family)
-          if sizes&.any?
+          if sizes == :unread
+            lines << "" << "_Table sizes were not read: the read failed or took longer than query_timeout._"
+          elsif sizes&.any?
             lines << "" << "### Table Sizes"
             lines << "| Table | Size |"
             lines << "|-------|------|"
@@ -141,7 +143,9 @@ module RailsAiContext
           # Index usage (full detail only)
           if RailsAiContext::DetailLevel.full?(detail)
             index_usage = gather_index_usage(conn, family)
-            if index_usage.nil? && family.known?
+            if index_usage == :unread
+              lines << "" << "_Index usage was not read: the read failed or took longer than query_timeout._"
+            elsif index_usage.nil? && family.known?
               lines << "" << "_Index usage is not available for the #{family.name} database family._"
             elsif index_usage&.any?
               lines << "" << "### Index Usage"
@@ -171,7 +175,7 @@ module RailsAiContext
 
           AppDatabases.bounded(conn) { family.table_sizes(conn) }&.reject { |r| INTERNAL_TABLES.include?(r[:name]) }
         rescue => e
-          RailsAiContext.debug_fail(e, nil, label: "gather_table_sizes")
+          RailsAiContext.debug_fail(e, :unread, label: "gather_table_sizes")
         end
 
         # Every database Rails migrates here, each through its own connection.
@@ -235,7 +239,7 @@ module RailsAiContext
         def gather_index_usage(conn, family)
           AppDatabases.bounded(conn) { family.index_usage(conn) } if family.known?
         rescue => e
-          RailsAiContext.debug_fail(e, [], label: "gather_index_usage")
+          RailsAiContext.debug_fail(e, :unread, label: "gather_index_usage")
         end
 
         # ── Cache section ────────────────────────────────────────────────

data/lib/rails_ai_context/tools/safe_call.rb

@@ -89,9 +89,8 @@ module RailsAiContext
             response, left_out = with_left_out_frame { RailsAiContext::RunCache.around { yield } }
             response = append_note(response, RailsAiContext::Tools::BaseTool.left_out_note(left_out))
             append_note(response, invalid_detail_note(discarded))
-          # ScriptError too: a SyntaxError or LoadError out of an app file the
-          # tool reached must cost that call, not the stdio server and every
-          # tool with it. So must a stack overflow or a SecurityError.
+          # An app file that cannot load, a stack overflow or a SecurityError costs that call,
+          # where a StandardError rescue alone would let it end the stdio server and every tool with it.
           rescue StandardError, ScriptError, SystemStackError, SecurityError => e
             failure_response(e).tap do |failure|
               call = Thread.current[:rails_ai_context_call]

data/lib/rails_ai_context/tools/session_context.rb

@@ -73,9 +73,8 @@ module RailsAiContext
           [ tool, params ]
         end
 
-        # The tool a mark names, spelled the way the server names it, so a
-        # mark and the call it stands for are one entry, and the config section
-        # a retired name stands for. Takes the short forms the CLI takes.
+        # The tool a mark names, spelled as the server names it, so a mark and the call it stands for are one
+        # entry, with the config section a retired name stands for. Takes the short forms the CLI takes.
         def known_tool(name)
           return nil if name.to_s.empty?
 

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "5.35.1"
+  VERSION = "5.35.2"
 end

data/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.35.1",
+  "version": "5.35.2",
   "packages": [
     {
       "registryType": "mcpb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.35.1
+  version: 5.35.2
 platform: ruby
 authors:
 - crisnahine