rails-ai-context 5.30.0 → 5.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdbf8aa4b69d34178b8de050d97cd83b440c522c46cb88669282310dd8b5781e
-  data.tar.gz: 7f82a14e208481dda4b35e2a78f7f95ed943d6ca4d912357a12f513d389ad968
+  metadata.gz: e31095f85a3f90825fbd66bf2a7deae9224ac4fe94474c8d60da20c46ed52b47
+  data.tar.gz: 190a7d48230b4ae98300b2619a0d2cf7a1ddb8a6e24619a7a54cfa3a6e5b233b
 SHA512:
-  metadata.gz: 45dfba73734c8044fff7075b73c6e70280bb305b0a9cd13542055da30dafb7aded28584fddd2897f16dce6aea03e725022aeb9659bc026c1b23ccf7c19930059
-  data.tar.gz: 1c11ac34c10dc55010c769091dcaff297656f60489f676f0bf4951ebb10dd05238692fd233d0916eeae6eefeea6d3c05f24aee7dd078ed6e1fd9596a4dc72c93
+  metadata.gz: f91198dc48ae6f259c0f4d170b0fbae5d2174fa142a64530ef4ac46f2e6c51c9e22e54057e7f64712f06fc76a085e45994da2a9dc592edfe9ee3f0366608d642
+  data.tar.gz: cee2a7a2d636322fddeedcffa151812d0ae8c52cde17d99394fd7dded5e30e5bddb8db288bc9b31b0fe1281a9a33270739c000735957fab6d64cbafdfec8a149

data/CHANGELOG.md

@@ -5,6 +5,43 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.30.1] - 2026-09-28
+
+### Fixed
+
+- **A PostgreSQL partitioned table is one table wherever its partitions can be
+  told apart.** The booted schema listed each partition as a table of its own,
+  repeating the parent's columns, indexes and keys, and one app went from 98
+  tables to 211. The schema.rb and structure.sql readers did the same with the
+  partitions Rails and pg_dump write out, and schema.rb's copies of the parent's
+  foreign keys and check constraints came with them. A foreign key to a
+  partitioned table, which PostgreSQL clones once per partition, is listed once.
+  A schema.rb from before Rails 8 does not mark partitions, so the booted schema
+  asks the primary database which tables are partitions. Everything else that
+  reads such a file, the static tier and a secondary database's dump included,
+  still lists them. A table that inherits another through `INHERITS` is not a
+  partition and keeps its own entry. (#250)
+- **Database stats and `rails_runtime_info` count a partition as part of its
+  parent.** Row counts and table sizes, which listed the parent at zero or left
+  it out, add each partition's rows and bytes to it, and index usage, which
+  listed an index once per partition, names it once. All three break ties by
+  name. On PostgreSQL 10 and 11, which lack `pg_partition_root`, they still list
+  each partition. (#250)
+- **A foreign key over more than one column reads as a column list.**
+  `rails_get_schema` and `rails-schema.md` printed a Ruby array literal for its
+  columns, `["event_id", "event_day"]`, and now write `(event_id, event_day)` →
+  `events.(id, day)`. `rails_validate` warned that such a key had no index even
+  when one led with its columns, with a generator command Rails cannot run, and
+  now suggests one `add_index` over the columns. A foreign key to a partitioned
+  table spans more than one column whenever the partition column is not its key.
+- **A PostGIS app gets PostgreSQL's answers.** `activerecord-postgis-adapter`
+  reports `PostGIS` for what is a PostgreSQL connection, and matching only
+  `postgresql` sent `rails_query` down the unguarded path with no READ ONLY
+  transaction and no statement timeout, skipped database stats and
+  `rails_runtime_info`'s table sizes and index usage, and dropped
+  `rails_migration_advisor`'s Strong Migrations warning for an `add_index`
+  without `algorithm: :concurrently`.
+
 ## [5.30.0] - 2026-09-28
 
 A pass over the whole tree for code that did not need to exist, with one base

data/docs/ARCHITECTURE.md

@@ -111,7 +111,7 @@ flowchart LR
 
 The `Introspector` orchestrator runs configured introspectors and merges results.
 
-Four modules answer questions every introspector used to answer for itself:
+Five modules answer questions every introspector used to answer for itself:
 
 - **PathResolver** - where a kind of app code lives: `app/<kind>`, packs, and the in-repo code roots read from the tree (a directory holding its own `app/` plus a gemspec, `plugin.rb` or `lib/**/engine.rb`), memoized per root
 - **SourceScan** - one walk over a kind of app source, across every directory `PathResolver` resolves: `paths` stats, `each` reads, `classes` names by the declared constant
@@ -119,6 +119,10 @@ Four modules answer questions every introspector used to answer for itself:
 - **GemLock** - which gems the app resolved and at what version, read once per lockfile and matched by exact name across GEM, GIT and PATH
 - **PackageJson** - which npm packages the app depends on, read once per `package.json`: present means named in `dependencies` or `devDependencies`, so an `overrides` pin is not a dependency, and `@tailwindcss/vite` counts as tailwindcss
 
+One more reads PostgreSQL's catalogs for the schema, the database stats and `rails_runtime_info`:
+
+- **PgPartitions** - which tables are partitions, and each table's rows, bytes and index scans from `pg_stat_user_tables` and `pg_stat_user_indexes`, counting a partition toward its partitioned parent, so every surface names a partitioned table once
+
 Two more answer a question a tool asks:
 
 - **PendingMigrations** - which migration files are not in the applied set, from one derivation both the schema and migrations sections read

data/docs/COMPATIBILITY.md

@@ -211,7 +211,11 @@ Proof sources:
    In the v5.30.0 release QA: Mastodon, Discourse, OpenProject, Canvas, Forem,
    Whitehall, Consul, OpenFoodNetwork, Huginn, Errbit, Diaspora and Plots2 in
    the static and failed-boot tiers, and the same private app in every tier
-   and both install paths.
+   and both install paths. In the v5.30.1 release QA: the same private app on
+   PostgreSQL 17 with a partitioned table added, booted and static from
+   schema.rb and structure.sql, a Rails 7.2 app whose schema.rb carries no
+   partition marker, and Discourse, Mastodon, OpenFoodNetwork and Forem
+   answering as before.
 2. Non-crash coverage for every built-in tool including `get_view` in
    `spec/e2e/in_gemfile_install_spec.rb`'s full-tool sweep; output correctness
    (ivar cross-check, render-form detection, partial interfaces) verified

data/lib/rails_ai_context/introspectors/database_stats_introspector.rb

@@ -2,8 +2,8 @@
 
 module RailsAiContext
   module Introspectors
-    # Collects approximate row counts from PostgreSQL's pg_stat_user_tables.
-    # Only activates for PostgreSQL adapter; returns { skipped: true } otherwise.
+    # Approximate row counts per table on PostgreSQL, MySQL and SQLite; any
+    # other adapter returns { skipped: true }.
     class DatabaseStatsIntrospector < Base
       extend StaticTier
       static_tier :runtime_only
@@ -13,12 +13,15 @@ module RailsAiContext
       # stats collection 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 call
         return { skipped: true, reason: "ActiveRecord not available" } unless defined?(ActiveRecord::Base)
 
         adapter = ActiveRecord::Base.connection.adapter_name.downcase
         case adapter
-        when /postgresql/
+        when POSTGRES_ADAPTER
           collect_postgresql_stats
         when MYSQL_ADAPTER
           collect_mysql_stats
@@ -32,18 +35,10 @@ module RailsAiContext
       private
 
       def collect_postgresql_stats
-        rows = ActiveRecord::Base.connection.select_all(<<~SQL)
-          SELECT relname AS table_name,
-                 n_live_tup AS approximate_row_count,
-                 n_dead_tup AS dead_rows
-          FROM pg_stat_user_tables
-          ORDER BY n_live_tup DESC
-        SQL
-
-        tables = rows.map do |row|
-          entry = { table: row["table_name"], approximate_rows: row["approximate_row_count"].to_i }
-          dead = row["dead_rows"].to_i
-          entry[:dead_rows] = dead if dead > 0
+        stats = PgPartitions.table_rows(ActiveRecord::Base.connection).sort_by { |t| [ -t[:rows], t[:name] ] }
+        tables = stats.map do |t|
+          entry = { table: t[:name], approximate_rows: t[:rows] }
+          entry[:dead_rows] = t[:dead_rows] if t[:dead_rows] > 0
           entry
         end
 

data/lib/rails_ai_context/introspectors/listeners/schema_dsl_listener.rb

@@ -72,8 +72,8 @@ module RailsAiContext
             to:          to_arg.unescaped,
             # Absent means the Rails convention holds; naming it here would
             # make a declared column indistinguishable from a guessed one.
-            column:      options[:column]&.to_s,
-            primary_key: options[:primary_key]&.to_s,
+            column:      SchemaConventions.primary_key_value(options[:column]),
+            primary_key: SchemaConventions.primary_key_value(options[:primary_key]),
             location:    node.location.start_line
           }.compact
         end

data/lib/rails_ai_context/introspectors/pg_partitions.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # A partition repeats its parent's columns, indexes and keys, so it is listed
+    # as its partitioned parent, and its rows, bytes and index scans count there.
+    module PgPartitions
+      module_function
+
+      # activerecord-postgis-adapter reports "PostGIS" for what is a PostgreSQL connection.
+      POSTGRES_ADAPTER = /postg/i
+
+      # Scoped the way connection.tables is.
+      NAMES_SQL = <<~SQL.squish.freeze
+        SELECT c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relispartition AND c.relkind IN ('r', 'p') AND n.nspname = ANY (current_schemas(false))
+      SQL
+
+      def names(conn)
+        # relispartition arrived with partitions in 10; querying it before then
+        # fails, and a failed query aborts any open transaction.
+        return [] unless conn.adapter_name.match?(POSTGRES_ADAPTER) && conn.database_version >= 10_00_00
+
+        conn.select_values(NAMES_SQL)
+      rescue => e
+        RailsAiContext.debug_fail(e, [], label: "PgPartitions.names")
+      end
+
+      # @return [Array<Hash>] { name:, rows:, dead_rows: } per table, from the statistics alone
+      def table_rows(conn)
+        per_table(conn, "SUM(s.n_live_tup) AS live_rows, SUM(s.n_dead_tup) AS dead_rows").map do |r|
+          { name: r["name"], rows: r["live_rows"].to_i, dead_rows: r["dead_rows"].to_i }
+        end
+      end
+
+      # @return [Array<Hash>] { name:, bytes: } per table. Sizing a relation waits on its lock.
+      def table_bytes(conn)
+        per_table(conn, "SUM(pg_total_relation_size(s.relid)) AS bytes").map do |r|
+          { name: r["name"], bytes: r["bytes"].to_i }
+        end
+      end
+
+      # @return [Array<Hash>] { table:, index:, scans: } per index, from pg_stat_user_indexes
+      def index_stats(conn)
+        conn.select_all(<<~SQL).map do |r|
+          SELECT t.relname AS table_name, i.relname AS index_name, SUM(s.idx_scan) AS scans
+          FROM pg_stat_user_indexes s
+          JOIN pg_class t ON t.oid = #{root_of(conn, "s.relid")}
+          JOIN pg_class i ON i.oid = #{root_of(conn, "s.indexrelid")}
+          GROUP BY t.oid, t.relname, i.oid, i.relname
+        SQL
+          { table: r["table_name"], index: r["index_name"], scans: r["scans"].to_i }
+        end
+      end
+
+      def per_table(conn, sums)
+        conn.select_all(<<~SQL)
+          SELECT c.relname AS name, #{sums}
+          FROM pg_stat_user_tables s
+          JOIN pg_class c ON c.oid = #{root_of(conn, "s.relid")}
+          GROUP BY c.oid, c.relname
+        SQL
+      end
+      private_class_method :per_table
+
+      def root_of(conn, relid)
+        # ponytail: pg_partition_root needs PostgreSQL 12, so on 10 and 11 each partition stays its own row.
+        conn.database_version >= 12_00_00 ? "COALESCE(pg_partition_root(#{relid}), #{relid})" : relid
+      end
+      private_class_method :root_of
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/schema_conventions.rb

@@ -32,8 +32,8 @@ module RailsAiContext
       def foreign_key_entry(from, to, column, primary_key)
         {
           from_table: from, to_table: to,
-          column: column&.to_s || "#{to.to_s.singularize}_id",
-          primary_key: primary_key&.to_s || "id"
+          column: primary_key_value(column) || "#{to.to_s.singularize}_id",
+          primary_key: primary_key_value(primary_key) || "id"
         }
       end
 
@@ -63,6 +63,13 @@ module RailsAiContext
         (key ? leading << key.to_s : leading).to_set
       end
 
+      # A key as a reader writes it beside another key: `id`, or `(id, day)`, so
+      # the two sides of a foreign key stay apart.
+      def key_text(value)
+        columns = Array(value).map(&:to_s)
+        columns.size > 1 ? "(#{columns.join(", ")})" : columns.first.to_s
+      end
+
       # A partial index's condition as the dump wrote it, for the end of a line.
       def where_clause(where)
         where ? " where #{where}" : ""

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -12,6 +12,7 @@ module RailsAiContext
       def call
         return attach_secondary_databases(static_schema_parse) unless active_record_connected?
 
+        @partitions = PgPartitions.names(connection)
         if table_names.empty?
           # Connected but not migrated: the files answer, and the notes say so.
           @connection_state = "connected, no tables yet"
@@ -77,7 +78,8 @@ module RailsAiContext
       end
 
       def table_names
-        @table_names ||= connection.tables.reject { |t| t.start_with?("ar_internal_metadata", "schema_migrations") }
+        @table_names ||= (connection.tables - @partitions.to_a)
+          .reject { |t| t.start_with?("ar_internal_metadata", "schema_migrations") }
       end
 
       def extract_tables
@@ -135,7 +137,8 @@ module RailsAiContext
       end
 
       def extract_foreign_keys(table)
-        connection.foreign_keys(table).map do |fk|
+        # PostgreSQL clones a key that references a partitioned table once per partition.
+        connection.foreign_keys(table).reject { |fk| @partitions.to_a.include?(fk.to_table) }.map do |fk|
           {
             from_table: fk.from_table,
             to_table: fk.to_table,
@@ -158,7 +161,7 @@ module RailsAiContext
       end
 
       def schema_reader
-        @schema_reader ||= SchemaReader.new(schema_file_path)
+        @schema_reader ||= SchemaReader.new(schema_file_path, partitions: @partitions.to_a)
       end
 
       # Constraints and enum types are declared in the dump, not reported by

data/lib/rails_ai_context/introspectors/schema_reader.rb

@@ -59,9 +59,12 @@ module RailsAiContext
 
       attr_reader :source
 
-      def initialize(path, pk_type: nil)
+      # partitions: the tables the database says are partitions, which a
+      # schema.rb from before Rails 8 dumps as plain tables.
+      def initialize(path, pk_type: nil, partitions: [])
         @path = path
         @pk_type = pk_type
+        @partitions = partitions
         @source = File.exist?(path.to_s) ? :schema_rb : :none
       end
 
@@ -147,11 +150,32 @@ module RailsAiContext
           current = absorb(event, schema, current)
         end
 
-        schema
+        drop_partitions(schema)
       rescue => e
         RailsAiContext.debug_fail(e, empty_schema, label: "SchemaReader")
       end
 
+      # Rails dumps a partition as a table inheriting its parent, and PostgreSQL
+      # lets only a partition inherit a partitioned table.
+      def drop_partitions(schema)
+        table_options = schema[:tables].transform_values { |t| t.dig(:options, :options).to_s }
+        partitioned = table_options.select { |_, o| o.start_with?("PARTITION BY") }.keys
+        dumped_partitions = []
+        loop do
+          found = table_options.select { |_, o| partitioned.include?(o[/\AINHERITS \(([^,]+)\)\z/, 1]) }.keys - dumped_partitions
+          break if found.empty?
+
+          dumped_partitions.concat(found)
+          partitioned.concat(found)
+        end
+        partitions = dumped_partitions | @partitions
+
+        partitions.each { |name| schema[:tables].delete(name) }
+        schema[:foreign_keys].reject! { |fk| partitions.include?(fk[:from]) || partitions.include?(fk[:to]) }
+        schema[:check_constraints].reject! { |c| partitions.include?(c[:table]) }
+        schema
+      end
+
       # AstCache caps parses below the configured schema limit, so a dump
       # between the two has to be parsed directly. Everything under the cap
       # goes through the cache, which the other introspectors share.

data/lib/rails_ai_context/introspectors/structure_sql_reader.rb

@@ -58,6 +58,9 @@ module RailsAiContext
           tables[from]&.dig(:foreign_keys)&.push({ from_table: from, to_table: to, column: col, primary_key: pk })
         end
 
+        # pg_dump writes each partition as a table, then attaches it in exactly this form.
+        content.scan(/^ALTER TABLE ONLY .+? ATTACH PARTITION (?:public\.)?(?:"([^"]+)"|(\w+)) /) { |quoted, bare| tables.delete(quoted || bare) }
+
         { dialect: detect_sql_dialect(content), tables: tables }
       end
 

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/tools/get_schema.rb

@@ -469,7 +469,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/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

@@ -124,6 +124,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
@@ -335,7 +338,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 +421,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

@@ -130,7 +130,7 @@ module RailsAiContext
                 lines << "**Unused indexes (0 scans):**"
                 unused.first(10).each { |i| lines << "- `#{i[:index]}` on `#{i[:table]}`" }
               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 +152,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 +206,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

data/lib/rails_ai_context/tools/validate_semantics.rb

@@ -684,7 +684,13 @@ module RailsAiContext
         indexed = Introspectors::SchemaConventions.lookup_indexed_columns(table_data)
 
         fk_columns.each do |col|
-          unless indexed.include?(col)
+          if col.is_a?(Array)
+            primary_key = { columns: Array(table_data[:primary_key] || table_data.dig(:options, :primary_key)) }
+            next if Introspectors::SchemaConventions.leading_index?(Array(table_data[:indexes]) + [ primary_key ], col)
+
+            warnings << "#{Introspectors::SchemaConventions.key_text(col)} in #{table_name} - foreign key without an index leading with its columns (slow queries). " \
+                        "Fix: `add_index :#{table_name}, [#{col.map { |c| ":#{c}" }.join(", ")}]`"
+          elsif !indexed.include?(col)
             warnings << "#{col} in #{table_name} - foreign key without index (slow queries). Fix: `rails g migration AddIndexTo#{table_name.camelize} #{col}:index`"
           end
         end

data/lib/rails_ai_context/version.rb

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

data/server.json

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.30.0
+  version: 5.30.1
 platform: ruby
 authors:
 - crisnahine
@@ -398,6 +398,7 @@ files:
 - lib/rails_ai_context/introspectors/node_source.rb
 - lib/rails_ai_context/introspectors/observability_introspector.rb
 - lib/rails_ai_context/introspectors/performance_introspector.rb
+- lib/rails_ai_context/introspectors/pg_partitions.rb
 - lib/rails_ai_context/introspectors/rake_task_introspector.rb
 - lib/rails_ai_context/introspectors/retry_policy.rb
 - lib/rails_ai_context/introspectors/route_introspector.rb