rails-ai-bridge 3.6.1 → 3.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc139c0066902b92342f732a9e9344b5aa5468153f6193708fa95815bbe0535
-  data.tar.gz: 05fe2c9d0ada4aa7a836b1dea1ec70f60ad75a94f87c4b4ff5b29e6c4fe9ca81
+  metadata.gz: 0ed19c9c79914f2b5ad8707d51a634c4bae469e3d7d07bd06cf23ed6d89a6027
+  data.tar.gz: b58364346943cfe18414ff86cfb08b95a5bfe5ffef5d9c9949d8eb2221af1c7d
 SHA512:
-  metadata.gz: 73de5c66876b8b4ca8e7a50e3bdaaf8700984f23f884f492d7ebc880aee3fd3345efd847c4d4252012ac920c8e5450877767e79e48ecdc141f74b0d0d5dc5dd8
-  data.tar.gz: '08b0c68f5f5af762af8c87e937ba5360f5fa6732f07b3543d24bb000e118f5dad55ca4228984f7f88dc471ea70b8f3a75f8ae4b3a3dbd4eacbef205be1683cfa'
+  metadata.gz: f883afb7b2d7c806c765e54ca0169ce845fe8a087633676408f5dec3931373f0f152edd4a7a1e49f876b26f213f5e8960dc994294fd17087df5c437a1445f9b3
+  data.tar.gz: e5d84fdd428ab13733063d67ef6589421a387c4c5a844ff04950afe1e9a90a79e3ad7556336853a0087f3bdeb797f8ece670ae192f5069e2f21daa12b4438512

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.2] - 2026-08-07
+
+### Added
+
+- **`structure.sql` support in offline/static schema introspection** (#96/#97/#116) — apps using `config.active_record.schema_format = :sql` (no `db/schema.rb`) now get table, column, index, and foreign-key context offline via `Introspectors::Schema::StaticStructureSqlParser`. The live-connection path was already format-agnostic. Output shape matches the live introspector so formatters work unchanged. Partition-child tables (`CREATE TABLE … PARTITION OF …`) are not expanded (follow-up).
+
+### Fixed
+
+- **`ai:doctor` schema check for `schema_format = :sql`** (#96/#97/#116) — Schema check passes when `db/structure.sql` is present; fix hint points at `rails db:migrate` (or `rails db:schema:dump`).
+
 ## [3.6.1] - 2026-08-07
 
 ### Security

data/README.md

@@ -781,7 +781,7 @@ Bug reports and pull requests: [github.com/igmarin/rails-ai-bridge/issues](https
 
 ## Acknowledgments & Origins
 
-This gem ships as **rails-ai-bridge** (Ruby **`RailsAiBridge`**, version **3.6.1**). Earlier iterations of the same codebase were distributed as `rails-ai-context`.
+This gem ships as **rails-ai-bridge** (Ruby **`RailsAiBridge`**, version **3.6.2**). Earlier iterations of the same codebase were distributed as `rails-ai-context`.
 
 RailsMCP evolved from 
 [crisnahine/rails-ai-context](https://github.com/crisnahine/rails-ai-context),

data/UPGRADING.md

@@ -1,5 +1,16 @@
 # Upgrading rails-ai-bridge
 
+## Upgrading from 3.6.1 to 3.6.2
+
+**No configuration changes required.**
+
+If your app uses `config.active_record.schema_format = :sql`, offline schema
+introspection and `rails ai:doctor` now use `db/structure.sql` automatically
+(no need for `db/schema.rb`). Live DB introspection was already format-agnostic.
+
+---
+
+
 ## Upgrading from 3.6.0 to 3.6.1
 
 **One action required if you are pinned to `rubydex` 0.2.x:**

data/lib/rails_ai_bridge/doctor/checkers/schema_checker.rb

@@ -3,18 +3,31 @@
 module RailsAiBridge
   class Doctor
     module Checkers
-      # Verifies +db/schema.rb+ exists for schema-driven AI context.
+      # Verifies a schema file exists for schema-driven AI context. Accepts
+      # either +db/schema.rb+ (+schema_format = :ruby+) or +db/structure.sql+
+      # (+schema_format = :sql+).
       class SchemaChecker < BaseChecker
-        # @return [Doctor::Check] +:pass+ when the schema file exists; +:warn+ otherwise
+        # @return [Doctor::Check] +:pass+ when a schema file exists; +:warn+ otherwise
         def call
-          schema_path = File.join(app.root, 'db/schema.rb')
+          schema_file = present_schema_file
           check(
             'Schema',
-            File.exist?(schema_path),
-            pass: { message: 'db/schema.rb found' },
-            fail: { status: :warn, message: 'db/schema.rb not found', fix: 'Run `rails db:schema:dump` to generate it' }
+            schema_file,
+            pass: { message: "#{schema_file} found" },
+            fail: {
+              status: :warn,
+              message: 'db/schema.rb or db/structure.sql not found',
+              fix: 'Run `rails db:migrate` (or `rails db:schema:dump`) to generate one'
+            }
           )
         end
+
+        private
+
+        # @return [String, nil] the schema file that exists (schema.rb preferred), or +nil+
+        def present_schema_file
+          %w[db/schema.rb db/structure.sql].find { |rel| File.exist?(File.join(app.root, rel)) }
+        end
       end
     end
   end

data/lib/rails_ai_bridge/introspectors/schema/static_structure_sql_parser.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module RailsAiBridge
+  module Introspectors
+    module Schema
+      # Parses a +db/structure.sql+ file as plain text, without a live database
+      # connection. This is the +schema_format = :sql+ counterpart to
+      # {StaticSchemaParser}: apps that keep their schema as SQL (common on
+      # Postgres, where +schema.rb+ cannot represent partitions, views,
+      # extensions, or custom SQL) have no +db/schema.rb+ to fall back to in
+      # offline environments (CI, Claude Code, agent contexts).
+      #
+      # Each instance is single-use: construct it with the file content and a
+      # configuration object, call {#call}, and discard. No mutable state
+      # escapes the instance.
+      #
+      # == Supported DDL (pg_dump / structure.sql form)
+      #
+      # * +CREATE TABLE [IF NOT EXISTS] [schema.]name (+ — opens a table context
+      # * +<name> <type> ...+ — a column line inside the table body; the leading
+      #   identifier is the column and the remainder (minus +NOT NULL+/+DEFAULT+)
+      #   is the SQL type. Table-level constraint lines (+CONSTRAINT+,
+      #   +PRIMARY KEY+, +FOREIGN KEY+, …) are skipped.
+      # * +);+ — closes the current table context
+      # * +CREATE [UNIQUE] INDEX name ON [schema.]table USING method (cols)+ —
+      #   adds an index entry (first simple column) to the named table.
+      #   Functional/expression indexes (e.g. +lower(email)+) are skipped.
+      # * +ALTER TABLE [ONLY] table ADD CONSTRAINT ... FOREIGN KEY (col)
+      #   REFERENCES ref_table (pk)+ — adds a foreign-key entry to +table+
+      #   (pg_dump emits these in a separate constraints section).
+      #
+      # Unlike {StaticSchemaParser} (whose +schema.rb+ static form leaves foreign
+      # keys empty), +structure.sql+ spells foreign keys out as parseable DDL, so
+      # this parser populates them offline — matching what the live
+      # {SchemaIntrospector} path reports.
+      #
+      # Internal Rails tables (+ar_internal_metadata+, +schema_migrations+) and
+      # any table matching {Config::Introspection#excluded_tables} are silently
+      # skipped.
+      #
+      # @example
+      #   content = File.read("db/structure.sql")
+      #   result  = StaticStructureSqlParser.new(content: content, config: RailsAiBridge.configuration).call
+      #   # => { adapter: "static_parse", tables: { ... }, total_tables: N, note: "..." }
+      #
+      # @see RailsAiBridge::Introspectors::SchemaIntrospector
+      # @see RailsAiBridge::Introspectors::Schema::StaticSchemaParser
+      class StaticStructureSqlParser
+        # Regex matching a +CREATE TABLE+ declaration, tolerating +IF NOT EXISTS+,
+        # a schema qualifier (+public.+), and optional quoting of either part.
+        TABLE_LINE = /\ACREATE TABLE (?:IF NOT EXISTS\s+)?(?:[\w"]+\.)?"?([A-Za-z_]\w*)"?\s*\(/
+
+        # Regex matching the end of a table body (+);+ at column zero).
+        TABLE_END_LINE = /\A\)/
+
+        # Regex matching a column definition inside a table body: leading
+        # whitespace, an identifier (optionally quoted), then the type/modifiers.
+        COLUMN_LINE = /\A\s+"?([A-Za-z_]\w*)"?\s+(.+)/
+
+        # Regex matching a +CREATE INDEX+ statement. Captures the target table
+        # and the raw parenthesised column list; only the first column is kept
+        # (parity with {StaticSchemaParser}).
+        INDEX_LINE = /\ACREATE\s+(?:UNIQUE\s+)?INDEX\s+.+?\s+ON\s+(?:[\w"]+\.)?"?([A-Za-z_]\w*)"?\s+(?:USING\s+\w+\s+)?\(([^)]+)\)/
+
+        # Regex matching an +ALTER TABLE [ONLY] [schema.]table+ statement, which
+        # in pg_dump precedes an +ADD CONSTRAINT+ line. Captures the target table.
+        ALTER_TABLE_LINE = /\AALTER TABLE (?:ONLY\s+)?(?:[\w"]+\.)?"?([A-Za-z_]\w*)"?/
+
+        # Regex matching an +ADD CONSTRAINT ... FOREIGN KEY (cols) REFERENCES
+        # [schema.]ref_table (pk)+ clause. Captures local columns, referenced
+        # table, and referenced columns.
+        FOREIGN_KEY_LINE = /FOREIGN KEY\s*\(([^)]+)\)\s*REFERENCES\s+(?:[\w"]+\.)?"?([A-Za-z_]\w*)"?\s*\(([^)]+)\)/
+
+        # Regex matching an +ON DELETE <action>+ clause on a foreign-key line.
+        ON_DELETE = /ON DELETE ([A-Z ]+?)(?=\s+ON UPDATE|\s+(?:NOT\s+)?(?:DEFERRABLE|VALID)|[,;)]|\z)/i
+
+        # Regex matching an +ON UPDATE <action>+ clause on a foreign-key line.
+        ON_UPDATE = /ON UPDATE ([A-Z ]+?)(?=\s+(?:NOT\s+)?(?:DEFERRABLE|VALID)|[,;)]|\z)/i
+
+        # Rails-managed tables that must never appear in introspection output.
+        INTERNAL_TABLES = %w[ar_internal_metadata schema_migrations].freeze
+
+        # Table-level constraint keywords that share a column line's shape but
+        # are not columns.
+        CONSTRAINT_KEYWORDS = %w[CONSTRAINT PRIMARY FOREIGN UNIQUE CHECK EXCLUDE LIKE DEFERRABLE].freeze
+
+        # @param content [String] full text of +db/structure.sql+
+        # @param config  [RailsAiBridge::Config::Introspection, RailsAiBridge::Configuration]
+        #   any object that responds to +#excluded_table?+
+        def initialize(content:, config:)
+          @content       = content
+          @config        = config
+          @tables        = {}
+          @current_table = nil
+          @in_table      = false
+          @alter_target  = nil
+        end
+
+        # Parse the structure.sql content and return the tables hash. Never
+        # raises — malformed or non-UTF-8 input is caught and reported as an
+        # error hash, per the introspector contract.
+        #
+        # @return [Hash{Symbol => Object}] with keys +:adapter+, +:tables+,
+        #   +:total_tables+, and +:note+; or +{ error: }+ on failure
+        def call
+          @content.each_line { |line| parse_line(line) }
+
+          {
+            adapter: 'static_parse',
+            tables: @tables,
+            total_tables: @tables.size,
+            note: 'Parsed from db/structure.sql (no DB connection)'
+          }
+        rescue StandardError => error
+          { error: "Failed to parse db/structure.sql: #{error.message}" }
+        end
+
+        private
+
+        # Dispatches a single line to the table-body handler or the top-level
+        # (create/index/alter/foreign-key) handlers.
+        #
+        # @param line [String]
+        # @return [void]
+        def parse_line(line)
+          return parse_body_line(line) if @in_table
+          return if parse_table_line?(line)
+          return if parse_index_line?(line)
+          return if parse_alter_table_line?(line)
+
+          parse_foreign_key_line?(line)
+        end
+
+        # Opens a table context on a +CREATE TABLE+ line. Sets +@current_table+
+        # to +nil+ for skipped tables while still tracking that we are inside a
+        # body, so the closing +);+ is honoured.
+        #
+        # @param line [String]
+        # @return [Boolean] +true+ if the line matched
+        def parse_table_line?(line)
+          match = TABLE_LINE.match(line)
+          return false unless match
+
+          name = match[1]
+          @in_table = true
+          @current_table = skip_table?(name) ? nil : name
+          @tables[@current_table] = { columns: [], indexes: [], foreign_keys: [] } if @current_table
+          true
+        end
+
+        # Handles a line while inside a table body: either the closing paren or a
+        # column definition (constraint lines are ignored).
+        #
+        # @param line [String]
+        # @return [void]
+        def parse_body_line(line)
+          if TABLE_END_LINE.match?(line)
+            @in_table = false
+            @current_table = nil
+            return
+          end
+
+          parse_column_line(line) if @current_table
+        end
+
+        # Appends a column to the current table unless the line is a table-level
+        # constraint.
+        #
+        # @param line [String]
+        # @return [void]
+        def parse_column_line(line)
+          match = COLUMN_LINE.match(line)
+          return unless match
+          return if constraint_keyword?(match[1])
+
+          @tables[@current_table][:columns] << { name: match[1], type: normalize_type(match[2]) }
+        end
+
+        # Adds an index entry (first column only) to the matching table. No-ops
+        # when the table is not present in +@tables+.
+        #
+        # @param line [String]
+        # @return [Boolean] +true+ if the line matched
+        def parse_index_line?(line)
+          match = INDEX_LINE.match(line)
+          return false unless match
+
+          column = first_index_column(match[2])
+          @tables[match[1]]&.dig(:indexes)&.push({ columns: column }) if column
+          true
+        end
+
+        # Records the target table of an +ALTER TABLE+ statement so a following
+        # +ADD CONSTRAINT ... FOREIGN KEY+ line can attach to it. Sets
+        # +@alter_target+ to +nil+ for skipped/unknown tables.
+        #
+        # @param line [String]
+        # @return [Boolean] +true+ if the line matched
+        def parse_alter_table_line?(line)
+          match = ALTER_TABLE_LINE.match(line)
+          return false unless match
+
+          @alter_target = @tables.key?(match[1]) ? match[1] : nil
+          true
+        end
+
+        # Appends a foreign-key entry to the current +@alter_target+ table. Mirrors
+        # the live introspector's shape (+from_table+, +to_table+, +column+,
+        # +primary_key+, +on_delete+, +on_update+), keeping the first column of a
+        # composite key for parity with index handling. No-ops without a target.
+        #
+        # @param line [String]
+        # @return [Boolean] +true+ if the line matched
+        def parse_foreign_key_line?(line)
+          match = FOREIGN_KEY_LINE.match(line)
+          return false unless match
+          return true unless @alter_target
+
+          @tables[@alter_target][:foreign_keys] << {
+            from_table: @alter_target,
+            to_table: match[2],
+            column: first_identifier(match[1]),
+            primary_key: first_identifier(match[3]),
+            on_delete: fk_action(line, ON_DELETE),
+            on_update: fk_action(line, ON_UPDATE)
+          }.compact
+          true
+        end
+
+        # Strips a trailing comma and the +DEFAULT ...+ / +NOT NULL+ / +NULL+
+        # modifiers to leave the bare SQL type.
+        #
+        # @param raw [String] everything after the column name
+        # @return [String] the SQL type (e.g. +"character varying"+, +"bigint"+)
+        def normalize_type(raw)
+          raw.strip
+             .sub(/,\s*\z/, '')
+             .sub(/\s+DEFAULT\b.*\z/i, '')
+             .sub(/\s+NOT\s+NULL\s*\z/i, '')
+             .sub(/\s+NULL\s*\z/i, '')
+             .strip
+        end
+
+        # Extracts the first column identifier from an index's parenthesised
+        # column list. Keeps plain and opclass-qualified columns
+        # (+col varchar_pattern_ops+ → +col+) but returns +nil+ for functional
+        # or expression indexes (+lower(email)+) so they are skipped rather than
+        # mis-attributed to the function name.
+        #
+        # @param columns [String] raw text between the index parentheses
+        # @return [String, nil]
+        def first_index_column(columns)
+          first = columns.split(',').first&.strip
+          return nil if first.nil? || first.include?('(')
+
+          first.slice(/[A-Za-z_]\w*/)
+        end
+
+        # Returns the first identifier from a (possibly composite) column list.
+        #
+        # @param columns [String] comma-separated column list
+        # @return [String, nil]
+        def first_identifier(columns)
+          columns.split(',').first&.slice(/[A-Za-z_]\w*/)
+        end
+
+        # Extracts a normalized foreign-key referential action (e.g. +CASCADE+,
+        # +SET NULL+) from a line, or +nil+ when the clause is absent.
+        #
+        # @param line [String]
+        # @param pattern [Regexp] {ON_DELETE} or {ON_UPDATE}
+        # @return [String, nil]
+        def fk_action(line, pattern)
+          match = pattern.match(line)
+          match && match[1].strip.squeeze(' ').upcase
+        end
+
+        # @param name [String]
+        # @return [Boolean] +true+ when +name+ is a table-level constraint keyword
+        def constraint_keyword?(name)
+          CONSTRAINT_KEYWORDS.include?(name.upcase)
+        end
+
+        # @param name [String]
+        # @return [Boolean] +true+ when +name+ is internal or excluded by config
+        def skip_table?(name)
+          INTERNAL_TABLES.any? { |t| name.start_with?(t) } ||
+            @config.excluded_table?(name)
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_bridge/introspectors/schema_introspector.rb

@@ -4,11 +4,13 @@ module RailsAiBridge
   module Introspectors
     # Extracts database schema information — tables, columns, indexes, and
     # foreign keys — from a live ActiveRecord connection when available, or by
-    # falling back to text-parsing +db/schema.rb+ via
-    # {Schema::StaticSchemaParser} when no connection is present (CI, Claude
-    # Code, offline environments).
+    # text-parsing the schema file when no connection is present (CI, Claude
+    # Code, offline environments). The static fallback prefers +db/schema.rb+
+    # ({Schema::StaticSchemaParser}) and falls back to +db/structure.sql+
+    # ({Schema::StaticStructureSqlParser}) for +schema_format = :sql+ apps.
     #
     # @see Schema::StaticSchemaParser
+    # @see Schema::StaticStructureSqlParser
     class SchemaIntrospector
       # @return [Rails::Application]
       attr_reader :app
@@ -127,15 +129,27 @@ module RailsAiBridge
         File.join(app.root, 'db', 'schema.rb')
       end
 
-      # Fallback: parse db/schema.rb as text when the DB is not connected.
-      # Delegates all parsing to {Schema::StaticSchemaParser}.
+      def structure_sql_path
+        File.join(app.root, 'db', 'structure.sql')
+      end
+
+      # Fallback used when the DB is not connected. Prefers +db/schema.rb+
+      # (Ruby DSL) and falls back to +db/structure.sql+ (raw SQL) so
+      # +schema_format = :sql+ apps still get schema context offline.
       #
-      # @return [Hash] parsed schema result, or +{ error: }+ when the file is absent
+      # @return [Hash] parsed schema result, or +{ error: }+ when neither file exists
       def static_schema_parse
-        path = schema_file_path
-        return { error: "No schema.rb found at #{path}" } unless File.exist?(path)
-
-        Schema::StaticSchemaParser.new(content: File.read(path), config: config).call
+        if File.exist?(schema_file_path)
+          Schema::StaticSchemaParser.new(content: File.read(schema_file_path), config: config).call
+        elsif File.exist?(structure_sql_path)
+          Schema::StaticStructureSqlParser.new(content: File.read(structure_sql_path), config: config).call
+        else
+          { error: "No db/schema.rb or db/structure.sql found in #{File.join(app.root, 'db')}" }
+        end
+      rescue StandardError => error
+        # Guards the exist?/read race (file removed between check and read) and
+        # any other read failure, honouring the introspector never-raise contract.
+        { error: "Failed to read schema file: #{error.message}" }
       end
     end
   end

data/lib/rails_ai_bridge/path_resolver.rb

@@ -9,7 +9,7 @@ module RailsAiBridge
   # PathResolver is deliberately used by every introspector that needs to
   # locate files on disk (controller, model, view, stimulus, turbo, auth,
   # api, config, action_text, activeStorage, nonArModels — 11 callers as of
-  # v3.6.1). It is NOT a god class despite high betweenness centrality in
+  # v3.6.2). It is NOT a god class despite high betweenness centrality in
   # graph analyses: a foundational path-resolution utility is expected to
   # sit at the centre of the introspector graph. Splitting it would spread
   # path-safety logic (traversal guards, safe joins) across multiple files

data/lib/rails_ai_bridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiBridge
-  VERSION = '3.6.1'
+  VERSION = '3.6.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-bridge
 version: !ruby/object:Gem::Version
-  version: 3.6.1
+  version: 3.6.2
 platform: ruby
 authors:
 - Ismael Marin
@@ -218,6 +218,7 @@ files:
 - lib/rails_ai_bridge/introspectors/rake_task_introspector.rb
 - lib/rails_ai_bridge/introspectors/route_introspector.rb
 - lib/rails_ai_bridge/introspectors/schema/static_schema_parser.rb
+- lib/rails_ai_bridge/introspectors/schema/static_structure_sql_parser.rb
 - lib/rails_ai_bridge/introspectors/schema_introspector.rb
 - lib/rails_ai_bridge/introspectors/seeds_introspector.rb
 - lib/rails_ai_bridge/introspectors/semantic_introspector.rb