schema_reaper 1.0.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7a7ccaeefa1c6ddc5597a3b54ebb358fdac16ba72e8413b79cc70ecdf9223e
-  data.tar.gz: e6a801a21a746da04c63416669c0cf35e55975b8af85b631502847bdba769189
+  metadata.gz: 22245618558de174144cf3732fbced500e89726cafdec2ab14bdefe35d535287
+  data.tar.gz: 95a26a72863e7f603d1d6894aed3f89948f34d85959359863db83e9d01cc5d1b
 SHA512:
-  metadata.gz: fd33e938eddd3fd6ffb0e50dca359a62ac6974573838605f627a999bed26114d7501f92ae9edb769053ba65b8ee2d5a6f1d5f7b01f84b39f8abb8707ca6113ce
-  data.tar.gz: aceba9a2f2fdcb55d8b780b5d1e85a7431c9a587f3592e019c3434e7e0e7343d60d10ee8f7063f4b888027f4bdf3c59e7caa09f04b82c1803e3d96afcef239a3
+  metadata.gz: f98dcbc99cf5a8527ecdfbce06dfce99f6f678971c9d60ee96a030ba0b71eeac731e39f0e8dc87e697a9d74dcfec95d1fb1cfe06549a5b3db55a36580da42a7c
+  data.tar.gz: dbcb412469b0bb09c2676706b5a11a6fb085649411d9af3c29d8e633fd208a9e83315905886cf9bc065af4d85a148cdab11101b9dc6ff09380887effbee17493

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 2.7
   NewCops: enable
   SuggestExtensions: false
 

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.0.3] - 2026-09-04
+
+### Changed
+- Richer gem metadata for the RubyGems page: expanded `description` (analyzer
+  list, safety model, gem-awareness, reporters), and added `bug_tracker_uri`,
+  `documentation_uri`, `wiki_uri` and `funding_uri` (GitHub Sponsors) link
+  metadata. No code change.
+
+## [1.0.2] - 2026-09-04
+
+### Changed
+- Lowered `required_ruby_version` to `>= 2.7.0` (was `>= 3.1.0`).
+  - Rewrote all 40 endless method definitions (`def x = ...`, a Ruby 3.0
+    feature) as classic `def ... end`.
+  - Added explicit `require "set"` where `Set` / `to_set` are used (autoloaded
+    only on Ruby 3.2+).
+  - `rubocop` `TargetRubyVersion` set to 2.7; CI matrix now 2.7–3.3.
+  - Every `lib/`, `spec/` and `exe/` file verified to parse under Ruby 2.7.0;
+    dependency-free modules exercised on a real 2.7 runtime. Runtime deps
+    (`prism` >= 2.7, `thor` >= 2.6, `pg`) all support 2.7.
+- No behaviour change; 29 specs unchanged.
+
+## [1.0.1] - 2026-09-04
+
+Superseded by 1.0.2 before release. Lowered the floor to `>= 3.0.0` only.
+
 ## [1.0.0] - 2026-09-04
 
 First stable release.

data/PRO.md

@@ -0,0 +1,98 @@
+# schema_reaper Pro — open-core plan
+
+The `schema_reaper` gem stays **MIT, free, and complete for its job**: schema
+introspection, the seven analyzers, static + runtime signal, staged migrations,
+`table`/`json`/`markdown`/`sarif` output, the CI baseline gate. Everything a
+solo developer or single app needs.
+
+**Pro** is a separate paid layer for *teams and multi-database estates* — the
+work that only pays off at scale and that individuals rarely need.
+
+---
+
+## Free vs Pro
+
+| Capability | Free (`schema_reaper`) | Pro (`schema_reaper-pro`) |
+|---|---|---|
+| PostgreSQL adapter | ✅ | ✅ |
+| MySQL / MariaDB adapter | — | ✅ |
+| 7 core analyzers | ✅ | ✅ |
+| Orphan-row + schema-drift analyzers | — | ✅ |
+| Runtime attribute tracker | ✅ (file sink) | ✅ + Redis / StatsD / OTLP sinks |
+| Reporters | table / json / markdown / sarif | + HTML, Slack, Jira, PR review comments |
+| Reclaimable estimate | bytes/row × est. rows | real `pg_total_relation_size`, index bloat, $ per cloud plan |
+| History / trend | local JSONL + `trend` | hosted timeline, burndown charts, per-team dashboards |
+| Baseline gate | one file | per-branch baselines, ownership routing (CODEOWNERS) |
+| Multi-database / shards | one DB per run | fan-out across N databases, divergence report |
+| Scheduled scans + alerts | — | ✅ (cron runner, "queue breached", "new dead column in `billing`") |
+| Mountable dashboard engine | — | ✅ `mount SchemaReaper::Pro::Engine` |
+| SSO, audit log, RBAC | — | ✅ (Enterprise) |
+| Support | GitHub issues, best effort | private issues, SLA |
+
+Pro depends on the OSS gem and reuses its analyzer registry — no fork, no
+divergence. New analyzers land in Free first unless they are inherently
+team-scale.
+
+---
+
+## Delivery & licensing
+
+- **Distribution**: private gem on a Gemfury / GitHub Packages source, installed
+  with a license-key-scoped token.
+
+  ```ruby
+  source "https://pro.schema-reaper.dev" do
+    gem "schema_reaper-pro"
+  end
+  ```
+
+- **License check**: offline-friendly signed key (Ed25519), 30-day grace if the
+  license server is unreachable. No phone-home of schema content — ever.
+- **License**: commercial EULA, per-organization. Source-available to
+  subscribers (read + patch), not redistributable.
+- **Trial**: 21-day full-feature key, no card.
+
+---
+
+## Pricing (draft)
+
+| Tier | Who | Price | Limits |
+|---|---|---|---|
+| **Solo Pro** | 1 dev, unlimited personal/side projects | $9 / mo ($90 / yr) | 3 databases |
+| **Team** | up to 10 devs | $49 / mo ($490 / yr) | 15 databases, Slack/Jira, scheduled scans |
+| **Business** | up to 50 devs | $199 / mo | unlimited databases, dashboard engine, priority support |
+| **Enterprise** | 50+ / regulated | custom (from ~$12k / yr) | SSO, audit log, RBAC, on-prem license server, SLA |
+
+Free forever for: OSS projects, students, and any single non-commercial
+database. Charity/edu 50% off.
+
+---
+
+## Hosted option (later — biggest ceiling)
+
+`schema-reaper.dev` SaaS: point it at a read-replica, get weekly reports, trend
+dashboards, PR comments, and alerts with zero gem install. Same tiers, +$X for
+the managed runner. Ship the self-hosted Pro gem first; the SaaS is Pro + a
+scheduler + a web app.
+
+---
+
+## Rollout order
+
+1. **Now**: Sponsor button, `PRO.md`, "Pro" section in README (waitlist link).
+2. **v1.1 (OSS)**: MySQL adapter groundwork, real size math — proves demand,
+   some lands free.
+3. **Pro 0.1**: private gem = MySQL + Slack reporter + scheduled scans + license
+   key. Sell to the first 10 teams at half price for feedback.
+4. **Pro 0.2**: dashboard engine, multi-DB fan-out, per-branch baselines.
+5. **SaaS beta**: once ~25 paying teams self-host.
+
+---
+
+## Principles
+
+- Free tier never gets *worse* to sell Pro. No crippling, no nag screens.
+- Anything a single app genuinely needs stays free.
+- Never transmit schema, data, or query text without explicit opt-in.
+- Pro features are the ones a 2-person team can't be bothered to build and a
+  50-person org will happily expense.

data/README.md

@@ -124,6 +124,21 @@ require:
 - Mountable dashboard engine, trend charts
 - MySQL adapter
 
+## Pro (for teams)
+
+The gem is free and complete for a single app. **schema_reaper Pro** adds the
+team-scale layer: MySQL adapter, multi-database fan-out, orphan-row and
+schema-drift analyzers, Slack/Jira/PR-comment reporters, real
+`pg_total_relation_size` + $ estimates, scheduled scans with alerts, and a
+mountable dashboard engine. See [PRO.md](PRO.md). Waitlist / early access:
+open an issue tagged `pro`.
+
+## Sponsor
+
+`schema_reaper` is MIT and maintained in the open. If it saved you disk, money,
+or a nasty migration, sponsor its development via the **Sponsor** button on the
+repo.
+
 ## Development
 
 ```

data/lib/schema_reaper/analyzers/base.rb

@@ -9,8 +9,13 @@ module SchemaReaper
     #   gem_columns  - Hash{table_name => Set<column_name>} reserved by gems
     #   config       - Config
     Context = Struct.new(:schema, :used_tokens, :runtime, :gem_columns, :config, keyword_init: true) do
-      def runtime = self[:runtime] || Runtime::Report.empty
-      def gem_columns = self[:gem_columns] || {}
+      def runtime
+        self[:runtime] || Runtime::Report.empty
+      end
+
+      def gem_columns
+        self[:gem_columns] || {}
+      end
     end
 
     # Shared plumbing for analyzers: schema access and token lookup helpers.
@@ -24,16 +29,29 @@ module SchemaReaper
       end
 
       # @return [Array<Finding>]
-      def call = raise NotImplementedError
+      def call
+        raise(NotImplementedError)
+      end
 
       private
 
       attr_reader :ctx
 
-      def schema = ctx.schema
-      def config = ctx.config
-      def runtime = ctx.runtime
-      def used?(token) = ctx.used_tokens.include?(token.to_s.downcase)
+      def schema
+        ctx.schema
+      end
+
+      def config
+        ctx.config
+      end
+
+      def runtime
+        ctx.runtime
+      end
+
+      def used?(token)
+        ctx.used_tokens.include?(token.to_s.downcase)
+      end
 
       def gem_reserved?(table, column)
         ctx.gem_columns.fetch(table, []).include?(column)

data/lib/schema_reaper/analyzers/dead_table.rb

@@ -54,7 +54,9 @@ module SchemaReaper
         ev
       end
 
-      def camelize(str) = str.split("_").map(&:capitalize).join
+      def camelize(str)
+        str.split("_").map(&:capitalize).join
+      end
     end
   end
 end

data/lib/schema_reaper/analyzers/registry.rb

@@ -13,7 +13,9 @@ module SchemaReaper
           @classes << klass unless @classes.include?(klass)
         end
 
-        def all = @classes
+        def all
+          @classes
+        end
       end
     end
   end

data/lib/schema_reaper/cli.rb

@@ -6,7 +6,9 @@ require_relative "../schema_reaper"
 module SchemaReaper
   # Command-line entry point. See `exe/schema_reaper`.
   class CLI < Thor
-    def self.exit_on_failure? = true
+    def self.exit_on_failure?
+      true
+    end
 
     class_option :config, type: :string, default: ".schema_reaper.yml",
                           desc: "path to config file"
@@ -48,13 +50,19 @@ module SchemaReaper
     end
 
     desc "version", "Print version"
-    def version = say(SchemaReaper::VERSION)
+    def version
+      say(SchemaReaper::VERSION)
+    end
 
     private
 
-    def config = @config ||= Config.load(options[:config])
+    def config
+      @config ||= Config.load(options[:config])
+    end
 
-    def run = Runner.new(config: config).run
+    def run
+      Runner.new(config: config).run
+    end
 
     def enforce_baseline(findings)
       new_ones = Baseline.new(config.baseline_path).new_among(findings)

data/lib/schema_reaper/config.rb

@@ -44,15 +44,41 @@ module SchemaReaper
       @data["database_url"] || ENV.fetch("DATABASE_URL", nil)
     end
 
-    def scan_paths      = @data["scan_paths"]
-    def view_globs      = @data["view_globs"]
-    def ignore_tables   = @data.dig("ignore", "tables").to_a
-    def min_age_days    = @data["min_age_days"]
-    def baseline_path   = @data["baseline"]
-    def runtime_log     = @data["runtime_log"]
-    def history_log     = @data["history_log"]
-    def gem_awareness?  = @data["gem_awareness"] != false
-    def require_paths   = @data["require"].to_a
+    def scan_paths
+      @data["scan_paths"]
+    end
+
+    def view_globs
+      @data["view_globs"]
+    end
+
+    def ignore_tables
+      @data.dig("ignore", "tables").to_a
+    end
+
+    def min_age_days
+      @data["min_age_days"]
+    end
+
+    def baseline_path
+      @data["baseline"]
+    end
+
+    def runtime_log
+      @data["runtime_log"]
+    end
+
+    def history_log
+      @data["history_log"]
+    end
+
+    def gem_awareness?
+      @data["gem_awareness"] != false
+    end
+
+    def require_paths
+      @data["require"].to_a
+    end
 
     def always_keep_columns
       @data["always_keep_columns"].to_a

data/lib/schema_reaper/finding.rb

@@ -19,7 +19,9 @@ module SchemaReaper
       [type, table, column, index].compact.join("/")
     end
 
-    def reclaimable_bytes = self[:reclaimable_bytes] || 0
+    def reclaimable_bytes
+      self[:reclaimable_bytes] || 0
+    end
 
     def to_h
       super.merge(id: id, reclaimable_bytes: reclaimable_bytes)

data/lib/schema_reaper/gem_awareness.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module SchemaReaper
   # Columns and tables that popular gems own and reference indirectly (through
   # metaprogramming the static scanner cannot see). Detected gems get their

data/lib/schema_reaper/migration_generator.rb

@@ -61,7 +61,12 @@ module SchemaReaper
       path
     end
 
-    def camel = "#{@table}_#{@column}".split("_").map(&:capitalize).join
-    def model = @table.split("_").map(&:capitalize).join.sub(/s$/, "")
+    def camel
+      "#{@table}_#{@column}".split("_").map(&:capitalize).join
+    end
+
+    def model
+      @table.split("_").map(&:capitalize).join.sub(/s$/, "")
+    end
   end
 end

data/lib/schema_reaper/reporters/markdown.rb

@@ -35,7 +35,9 @@ module SchemaReaper
         end
       end
 
-      def total = @findings.sum(&:reclaimable_bytes)
+      def total
+        @findings.sum(&:reclaimable_bytes)
+      end
     end
   end
 end

data/lib/schema_reaper/reporters/sarif.rb

@@ -61,7 +61,9 @@ module SchemaReaper
         end
       end
 
-      def camelize(str) = str.split("_").map(&:capitalize).join
+      def camelize(str)
+        str.split("_").map(&:capitalize).join
+      end
     end
   end
 end

data/lib/schema_reaper/reporters/table.rb

@@ -39,7 +39,9 @@ module SchemaReaper
         @findings.sort_by { |f| [-f.confidence, SEV_ORDER.fetch(f.severity, 9)] }
       end
 
-      def total_reclaimable = @findings.sum(&:reclaimable_bytes)
+      def total_reclaimable
+        @findings.sum(&:reclaimable_bytes)
+      end
     end
   end
 end

data/lib/schema_reaper/runner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module SchemaReaper
   # Ties introspection + scanning + runtime data + analyzers together.
   class Runner

data/lib/schema_reaper/runtime.rb

@@ -11,7 +11,9 @@ module SchemaReaper
   module Runtime
     # Aggregated view of a usage log, consumed by analyzers.
     Report = Struct.new(:accessed, :observed_days, keyword_init: true) do
-      def self.empty = new(accessed: Set.new, observed_days: 0)
+      def self.empty
+        new(accessed: Set.new, observed_days: 0)
+      end
 
       def self.load(path)
         return empty unless path && File.exist?(path)
@@ -36,9 +38,17 @@ module SchemaReaper
         ((Time.parse(last) - Time.parse(first)) / 86_400).ceil
       end
 
-      def empty? = accessed.empty?
-      def present? = !empty?
-      def read?(table, column) = accessed.include?("#{table}.#{column}")
+      def empty?
+        accessed.empty?
+      end
+
+      def present?
+        !empty?
+      end
+
+      def read?(table, column)
+        accessed.include?("#{table}.#{column}")
+      end
     end
 
     # Buffered writer for the usage log. Thread-safe append of JSON lines.

data/lib/schema_reaper/schema.rb

@@ -9,26 +9,42 @@ module SchemaReaper
     keyword_init: true
   ) do
     # true when every row holds NULL (pg_stats null_frac == 1)
-    def always_null? = null_fraction && null_fraction >= 1.0
+    def always_null?
+      null_fraction && null_fraction >= 1.0
+    end
 
     # true when the column holds exactly one distinct non-null value
-    def single_value? = distinct_values == 1
+    def single_value?
+      distinct_values == 1
+    end
   end
 
   Index = Struct.new(:name, :columns, :unique, :primary, :scans, keyword_init: true) do
-    def covers?(other) = columns.first(other.columns.length) == other.columns
+    def covers?(other)
+      columns.first(other.columns.length) == other.columns
+    end
   end
 
   Table = Struct.new(
     :name, :columns, :indexes, :primary_key, :foreign_keys, :row_count,
     keyword_init: true
   ) do
-    def column_names = columns.map(&:name)
-    def column(name) = columns.find { |c| c.name == name }
-    def index_on(cols) = indexes.find { |i| i.columns == Array(cols) }
+    def column_names
+      columns.map(&:name)
+    end
+
+    def column(name)
+      columns.find { |c| c.name == name }
+    end
+
+    def index_on(cols)
+      indexes.find { |i| i.columns == Array(cols) }
+    end
   end
 
   DatabaseSchema = Struct.new(:tables, keyword_init: true) do
-    def table(name) = tables.find { |t| t.name == name }
+    def table(name)
+      tables.find { |t| t.name == name }
+    end
   end
 end

data/lib/schema_reaper/static/scanner.rb

@@ -10,7 +10,7 @@ module SchemaReaper
     # safe, a false "dead" is not.
     class Scanner
       RUBY_GLOB  = "**/*.rb"
-      WORD_RE    = /[a-z_][a-z0-9_]*/i
+      WORD_RE    = /[a-z_][a-z0-9_]*/i.freeze
 
       # Node classes whose #name (or #unescaped) is a bare identifier we treat
       # as a possible column/table reference.

data/lib/schema_reaper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaReaper
-  VERSION = "1.0.0"
+  VERSION = "1.0.3"
 end

data/lib/schema_reaper.rb

@@ -40,5 +40,7 @@ module SchemaReaper
     "sarif" => Reporters::Sarif
   }.freeze
 
-  def self.reporter(name) = REPORTERS.fetch(name, Reporters::Table)
+  def self.reporter(name)
+    REPORTERS.fetch(name, Reporters::Table)
+  end
 end

data/schema_reaper.gemspec

@@ -8,25 +8,51 @@ Gem::Specification.new do |spec|
   spec.authors = ["aksshatt"]
   spec.email = ["akshatpegwar5@gmail.com"]
 
-  spec.summary = "Find dead columns, unused indexes and schema dead-weight in Rails/ActiveRecord apps."
+  spec.summary = "Find dead columns, dead tables, unused indexes and other schema dead-weight " \
+                 "in Rails/ActiveRecord apps -- then remove it safely."
   spec.description = <<~DESC
-    schema_reaper scans your PostgreSQL schema, its planner statistics and your
-    codebase to surface columns, indexes and tables that are no longer used:
-    dead columns and tables, unused and duplicate indexes, missing foreign-key
-    indexes, always-NULL and single-value columns. Findings are scored by
-    confidence (fusing an optional runtime attribute-access signal), carry a
-    reclaimable-bytes estimate, and come with staged, reversible migrations.
-    Ships table/json/markdown/sarif reporters, a CI baseline gate and a trend
-    log.
+    schema_reaper reads your live PostgreSQL schema and planner statistics and
+    cross-references them against a Prism-AST static scan of your codebase
+    (models, views, SQL string literals). With an optional runtime signal -- a
+    sampled log of which columns are actually read in production -- it fuses
+    static and runtime evidence into a confidence score per finding.
+
+    Analyzers:
+      * dead_column         -- column no code path references
+      * dead_table          -- table with no model/query reference, zero rows
+      * unused_index        -- non-unique index, idx_scan = 0 in pg_stat
+      * duplicate_index     -- index that is a prefix of a wider index
+      * missing_fk_index    -- foreign-key / *_id column with no covering index
+      * always_null_column  -- pg_stats null_frac = 1.0, carries no data
+      * single_value_column -- one distinct value across a large table
+
+    Every finding carries a reclaimable-bytes estimate (from row counts) and a
+    concrete fix. `generate-migration` emits a staged, reversible pair:
+    ignored_columns first, remove_column after a soak. Nothing is dropped
+    automatically. Columns owned by common gems (devise, paper_trail,
+    activestorage, actiontext, friendly_id, audited, pg_search, ahoy_matey,
+    paranoia) are whitelisted when the gem is in your bundle.
+
+    Reporters: table, json, markdown (PR comments), SARIF 2.1.0 (GitHub code
+    scanning). `scan --ci` gates only findings absent from a committed baseline.
+    `trend` keeps an append-only history log for cleanup burndown. A Rails
+    railtie adds rake tasks and an opt-in runtime tracker. Custom analyzers
+    load through the `require:` config key.
+
+    PostgreSQL only for now (MySQL adapter on the roadmap). Ruby >= 2.7.
   DESC
   spec.homepage = "https://github.com/aksshatt/schema_reaper"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = spec.homepage
+  spec.metadata["changelog_uri"]     = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"]   = "#{spec.homepage}/issues"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}#readme"
+  spec.metadata["wiki_uri"]          = "#{spec.homepage}/wiki"
+  spec.metadata["funding_uri"]       = "https://github.com/sponsors/aksshatt"
   spec.metadata["rubygems_mfa_required"] = "true"
 
   spec.files = Dir.chdir(__dir__) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_reaper
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.3
 platform: ruby
 authors:
 - aksshatt
@@ -79,14 +79,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.5'
 description: |
-  schema_reaper scans your PostgreSQL schema, its planner statistics and your
-  codebase to surface columns, indexes and tables that are no longer used:
-  dead columns and tables, unused and duplicate indexes, missing foreign-key
-  indexes, always-NULL and single-value columns. Findings are scored by
-  confidence (fusing an optional runtime attribute-access signal), carry a
-  reclaimable-bytes estimate, and come with staged, reversible migrations.
-  Ships table/json/markdown/sarif reporters, a CI baseline gate and a trend
-  log.
+  schema_reaper reads your live PostgreSQL schema and planner statistics and
+  cross-references them against a Prism-AST static scan of your codebase
+  (models, views, SQL string literals). With an optional runtime signal -- a
+  sampled log of which columns are actually read in production -- it fuses
+  static and runtime evidence into a confidence score per finding.
+
+  Analyzers:
+    * dead_column         -- column no code path references
+    * dead_table          -- table with no model/query reference, zero rows
+    * unused_index        -- non-unique index, idx_scan = 0 in pg_stat
+    * duplicate_index     -- index that is a prefix of a wider index
+    * missing_fk_index    -- foreign-key / *_id column with no covering index
+    * always_null_column  -- pg_stats null_frac = 1.0, carries no data
+    * single_value_column -- one distinct value across a large table
+
+  Every finding carries a reclaimable-bytes estimate (from row counts) and a
+  concrete fix. `generate-migration` emits a staged, reversible pair:
+  ignored_columns first, remove_column after a soak. Nothing is dropped
+  automatically. Columns owned by common gems (devise, paper_trail,
+  activestorage, actiontext, friendly_id, audited, pg_search, ahoy_matey,
+  paranoia) are whitelisted when the gem is in your bundle.
+
+  Reporters: table, json, markdown (PR comments), SARIF 2.1.0 (GitHub code
+  scanning). `scan --ci` gates only findings absent from a committed baseline.
+  `trend` keeps an append-only history log for cleanup burndown. A Rails
+  railtie adds rake tasks and an opt-in runtime tracker. Custom analyzers
+  load through the `require:` config key.
+
+  PostgreSQL only for now (MySQL adapter on the roadmap). Ruby >= 2.7.
 email:
 - akshatpegwar5@gmail.com
 executables:
@@ -100,6 +121,7 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
+- PRO.md
 - README.md
 - Rakefile
 - exe/schema_reaper
@@ -143,6 +165,10 @@ metadata:
   homepage_uri: https://github.com/aksshatt/schema_reaper
   source_code_uri: https://github.com/aksshatt/schema_reaper
   changelog_uri: https://github.com/aksshatt/schema_reaper/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/aksshatt/schema_reaper/issues
+  documentation_uri: https://github.com/aksshatt/schema_reaper#readme
+  wiki_uri: https://github.com/aksshatt/schema_reaper/wiki
+  funding_uri: https://github.com/sponsors/aksshatt
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
@@ -152,7 +178,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -162,6 +188,6 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: Find dead columns, unused indexes and schema dead-weight in Rails/ActiveRecord
-  apps.
+summary: Find dead columns, dead tables, unused indexes and other schema dead-weight
+  in Rails/ActiveRecord apps -- then remove it safely.
 test_files: []