rails-ai-bridge 3.6.0 → 3.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b375ce08baa45d08d3c20625d27280862175bb022677e1f5c5ae90d1eb7a1493
-  data.tar.gz: 7d8de9d9b1642b447c03cc3b36820d2008dee648a475ebffaac038a9f081a178
+  metadata.gz: 0ed19c9c79914f2b5ad8707d51a634c4bae469e3d7d07bd06cf23ed6d89a6027
+  data.tar.gz: b58364346943cfe18414ff86cfb08b95a5bfe5ffef5d9c9949d8eb2221af1c7d
 SHA512:
-  metadata.gz: 6ced1f26479b6614723aaba77812ec4efe9ff35c107a40e4e8865ec88553eace62aa5bd990371c0eb1b2ae4bfd13d7983c1d101bb3403ef7b8e8922022150106
-  data.tar.gz: 39b6117bb858aa1dca13e65d05244aeccece63fb6afde51ee5ff1c0d3986512aabd3bd74e0ae00ee5ad0bda3382025573caebe7aa273155ff5a3fd85db03e812
+  metadata.gz: f883afb7b2d7c806c765e54ca0169ce845fe8a087633676408f5dec3931373f0f152edd4a7a1e49f876b26f213f5e8960dc994294fd17087df5c437a1445f9b3
+  data.tar.gz: e5d84fdd428ab13733063d67ef6589421a387c4c5a844ff04950afe1e9a90a79e3ad7556336853a0087f3bdeb797f8ece670ae192f5069e2f21daa12b4438512

data/CHANGELOG.md

@@ -5,6 +5,31 @@ 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).
 
+## [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
+
+- **Skill-pack git URL scheme allowlist** (#105/#110) — `DefaultGitRunner#clone_repo` accepts only `https://`, SCP-style `git@host:path`, and `ssh://`. Rejects `file://`, plain `http://`, and empty URLs. Validation `ArgumentError`s do not interpolate the raw URL, so credentials in userinfo cannot leak via exception messages.
+- **SECURITY.md supported-versions table** (#106/#112) — documents 3.6.x / 3.5.x as supported, best-effort for older 3.x, and end-of-life for 1.x / 2.x.
+- **Residual MCP HTTP risk checklist** (#107/#113) — operator checklist in `docs/mcp-security.md` (open HTTP default, CORS `*`, in-memory rate limit) with an install-generator pointer.
+
+### Changed
+
+- **`rubydex` bumped to `~> 0.3.0`** (#103/#111) — was `~> 0.2.9`. Run `bundle update rubydex` in host apps.
+- **Dependency audit (2026-08)** (#99) — `bundle-audit` clean; official `mcp` remains on **0.25.x** (`< 1.0`). Migration to `mcp` 1.x remains open in #104.
+
 ## [3.6.0]
 
 ### Changed

data/README.md

@@ -10,6 +10,7 @@
 [![CI](https://github.com/igmarin/rails-ai-bridge/actions/workflows/ci.yml/badge.svg)](https://github.com/igmarin/rails-ai-bridge/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 ![CodeRabbit Pull Request Reviews](https://img.shields.io/coderabbit/prs/github/igmarin/rails-ai-bridge?utm_source=oss&utm_medium=github&utm_campaign=igmarin%2Frails-ai-bridge&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/igmarin/rails-ai-bridge)
 
 ---
 
@@ -780,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.0**). 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/SECURITY.md

@@ -4,10 +4,12 @@
 
 | Version | Supported          |
 |---------|--------------------|
-| 3.0.x   | :white_check_mark: |
-| 2.x     | :white_check_mark: |
-| 1.x     | :white_check_mark: |
-| < 1.0   | :x:                |
+| 3.6.x   | :white_check_mark: |
+| 3.5.x   | :white_check_mark: |
+| 3.0.x–3.4.x | :white_check_mark: (security fixes best-effort) |
+| 2.x     | :x: (end of life — upgrade to 3.x) |
+| 1.x     | :x: |
+| < 1.0   | :x: |
 
 ## Reporting a Vulnerability
 

data/UPGRADING.md

@@ -1,5 +1,34 @@
 # 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:**
+
+The `rubydex` gem constraint moved from `~> 0.2.9` to `~> 0.3.0`. After upgrading
+rails-ai-bridge:
+
+```bash
+bundle update rubydex
+```
+
+No configuration or application code changes are required for the security and
+documentation updates in 3.6.1. Skill-pack git sources must use `https://`,
+SCP-style `git@host:path`, or `ssh://` (plain `http://` and `file://` are rejected).
+
+---
+
+
 ## Upgrading from 3.5.x to 3.6.0
 
 **One action required if you are pinned to an older `rubydex`:**

data/docs/mcp-security.md

@@ -72,3 +72,16 @@ The stdio MCP server has no Bearer layer; anyone who can run the process can use
 
 - [SECURITY.md](../SECURITY.md) — reporting vulnerabilities and design summary
 - [docs/GUIDE.md](GUIDE.md) — full configuration and MCP tool reference
+
+## Residual risk checklist (operators)
+
+Use this before exposing HTTP MCP beyond a single-developer machine:
+
+| Risk | Default | Mitigation |
+|------|---------|------------|
+| Unauthenticated HTTP when no token/resolver/JWT is configured | Open access (local DX) | Set `RAILS_AI_BRIDGE_MCP_TOKEN` or `config.http_mcp_token`, and/or `config.require_http_auth = true` |
+| `cors_origins` includes `*` | CORS disabled unless configured | Prefer exact origins; never combine `*` with browsers on untrusted networks |
+| In-memory rate limit | Per-process only | Use `config.mcp.rate_limiter` / reverse proxy / WAF for multi-worker or multi-host |
+| Information disclosure via tools | Read-only tools still reveal schema/routes/code | Prefer stdio; bind HTTP to `127.0.0.1`; use exclusions/presets for regulated data |
+
+See also [SECURITY.md](../SECURITY.md) for production `auto_mount` requirements and private vulnerability reporting.

data/lib/generators/rails_ai_bridge/install/install_generator.rb

@@ -189,6 +189,7 @@ module RailsAiBridge
             # return 401 unless one of the auth mechanisms above is configured.
             # Default is false for backward compatibility with local development.
             # config.mcp.require_http_auth = true
+            # See docs/mcp-security.md — Residual risk checklist (operators).
             #
             # Timing-safe token comparison is built in, but add rate limiting too
             # (e.g. Rack::Attack throttle on config.http_path) to prevent brute-force.

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.0). 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/registry/skill_source_resolver.rb

@@ -69,11 +69,22 @@ module RailsAiBridge
       #
       # @param url [String] git repository URL
       # @param dest [String] destination directory path
+      # @raise [ArgumentError] if the URL or destination is unsafe or not allowlisted
       # @raise [RuntimeError] if git clone command fails, returns non-zero, or times out
       # @return [void]
+      # @note Skill-pack clones accept only +https://+, SCP-style
+      #   +git@host:path+, and +ssh://+ remote URLs.
+      ALLOWED_GIT_URL_PATTERN = %r{\A(?:https://|ssh://|git@[A-Za-z0-9._-]+:)}
+
       def clone_repo(url, dest)
-        raise ArgumentError, "Invalid git URL #{url.inspect}: URLs must not start with '-'" if url.start_with?('-')
-        raise ArgumentError, "Invalid destination #{dest.inspect}: paths must not start with '-'" if dest.to_s.start_with?('-')
+        url = url.to_s
+        # Avoid interpolating +url+ into errors: userinfo may contain credentials.
+        raise ArgumentError, "Invalid git URL: URLs must not start with '-'" if url.start_with?('-')
+        raise ArgumentError, "Invalid destination: paths must not start with '-'" if dest.to_s.start_with?('-')
+        unless url.match?(ALLOWED_GIT_URL_PATTERN)
+          raise ArgumentError,
+                'Invalid git URL: scheme is not allowlisted (use https://, git@host:path, or ssh://)'
+        end
 
         with_timeout('git clone') do
           _stdout, stderr, status = Open3.capture3('git', 'clone', '--', url, dest)

data/lib/rails_ai_bridge/version.rb

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

data/rails-ai-bridge.gemspec

@@ -56,5 +56,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'zeitwerk', '~> 2.6' # Autoloading
 
   # Semantic code analysis via Shopify's rubydex
-  spec.add_dependency 'rubydex', '~> 0.2.9'
+  spec.add_dependency 'rubydex', '~> 0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-bridge
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.6.2
 platform: ruby
 authors:
 - Ismael Marin
@@ -89,14 +89,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.3.0
 description: Rails-AI-Bridge introspects your Rails application and exposes structure
   to AI assistants via static context files and a live Model Context Protocol (MCP)
   server. It classifies Active Record models semantically (Core, Join, Supporting),
@@ -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