rails-ai-context 4.3.3 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5568327e1027266892b2514cad27a3665532acfa1405236caecda030ff313739
-  data.tar.gz: 6be68e0d310f9a42aafc47161a676d162debba0cfe8a8f4087ee6051f79900cc
+  metadata.gz: 6fa4865cb6081dbc1a243371d270db6f80304fd5c3d7ccd8052d2c7c0d672dc6
+  data.tar.gz: 055a0fc1462f6a698e004090fda64703e98478af1d8bd1ca3426d85a5e9b6f69
 SHA512:
-  metadata.gz: 151fec5402860aa577e1c21af3ece8c0378a3f5b50f3e18e34236a43061d01da945a869972347e07d2748601c4e7965a449596fecb04cf1eecb0915a0ef73463
-  data.tar.gz: 18f46e2c0c1d638c3822687f949588dc5f9874cb61cf3f827827205e472456c95d7c55f74cec6a157bfa99531ab4849a9e14a9c23fce7676fc554463a934d9d3
+  metadata.gz: ac7a84cb7f54d6106c2bf33c94208f75871b9b8d25d304e0ddde0e36f73d3bd8e973dbf5f81b0665545548fd740fbdf60726a79195889cfbb9683cc733c80307
+  data.tar.gz: 440e13668f46d1578933bd5f053ea15cbae494938097f55380a0ab78c3a30a0f92dd74b20ad37edf7aed67f4aade37810e02b141e9d25e8963d40e3d63a650b9

data/CHANGELOG.md

@@ -5,6 +5,61 @@ 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).
 
+## [4.4.0] — 2026-04-03
+
+### Added
+- **33 introspector enhancements** — every introspector upgraded with new detection capabilities:
+  - **SchemaIntrospector**: expression indexes, column comments in static parse, `change_column_default`/`change_column_null` in migration replay
+  - **ModelIntrospector**: STI hierarchy detection (parent/children/type column), `attribute` API, enum `_prefix:`/`_suffix:`, `after_commit on:` parsing, inline `private def` exclusion
+  - **RouteIntrospector**: route parameter extraction, root route detection, RESTful action flag
+  - **JobIntrospector**: SolidQueue recurring job config, Sidekiq config (concurrency/queues), job callbacks (`before_perform`, `around_enqueue`, etc.)
+  - **GemIntrospector**: path/git gems from Gemfile, gem group extraction (dev/test/prod)
+  - **ConventionDetector**: multi-tenant (Apartment/ActsAsTenant), feature flags (Flipper/LaunchDarkly), error monitoring (Sentry/Bugsnag/Honeybadger), event-driven (Kafka/RabbitMQ/SNS), Zeitwerk detection, STI with type column verification
+  - **ControllerIntrospector**: `rate_limit` parsed into structured data (to/within/only), inline `private def` exclusion
+  - **StimulusIntrospector**: lifecycle hooks (connect/disconnect/initialize), outlet controller type mapping, action bindings from views (`data-action` parsing)
+  - **ViewIntrospector**: `yield`/`content_for` extraction from layouts, conditional layout detection with only/except
+  - **TurboIntrospector**: stream action semantics (append/update/remove counts), frame `src` URL extraction
+  - **I18nIntrospector**: locale fallback chain detection, locale coverage % per locale
+  - **ConfigIntrospector**: cache store options, error monitoring gem detection, job processor config (Sidekiq queues/concurrency)
+  - **ActiveStorageIntrospector**: attachment validations (content_type/size), variant definitions
+  - **ActionTextIntrospector**: Trix editor customization detection (toolbar/attachment/events)
+  - **AuthIntrospector**: OmniAuth provider detection, Devise settings (timeout/lockout/password_length)
+  - **ApiIntrospector**: GraphQL resolvers/subscriptions/dataloaders, API pagination strategy detection
+  - **TestIntrospector**: shared examples/contexts detection, database cleaner strategy
+  - **RakeTaskIntrospector**: task dependencies (`=> :prerequisite`), task arguments (`[:arg1, :arg2]`)
+  - **AssetPipelineIntrospector**: Bun bundler, Foundation CSS, PostCSS standalone detection
+  - **DevOpsIntrospector**: Fly.io/Render/Railway deployment detection, `docker-compose.yaml` support
+  - **ActionMailboxIntrospector**: mailbox callback detection (before/after/around_processing)
+  - **MigrationIntrospector**: `change_column_default`, `change_column_null`, `add_check_constraint` action detection
+  - **SeedsIntrospector**: CSV loader detection, seed ordering detection
+  - **MiddlewareIntrospector**: middleware added via initializers (`config.middleware.use/insert_before`)
+  - **EngineIntrospector**: route count + model count inside discovered engines
+  - **MultiDatabaseIntrospector**: shard names/keys/count from `connects_to`, improved YAML parsing for nested multi-db configs
+  - **ComponentIntrospector**: `**kwargs` splat prop detection
+  - **AccessibilityIntrospector**: heading hierarchy (h1-h6), skip link detection, `aria-live` regions, form input analysis (required/types)
+  - **PerformanceIntrospector**: polymorphic association compound index detection (`[type, id]`)
+  - **FrontendFrameworkIntrospector**: API client detection (Axios/Apollo/SWR/etc.), component library detection (MUI/Radix/shadcn/etc.)
+  - **DatabaseStatsIntrospector**: MySQL + SQLite support (was PostgreSQL-only), PostgreSQL dead row counts
+  - **ViewTemplateIntrospector**: slot reference detection
+  - **DesignTokenIntrospector**: Tailwind arbitrary value extraction
+
+### Fixed
+- **Security: SQLite SQL injection** — `database_stats_introspector` used string interpolation for table names in COUNT queries; now uses `conn.quote_table_name`
+- **Security: query column redaction bypass** — `SELECT password AS pwd` bypassed redaction; now also matches columns ending in `password`, `secret`, `token`, `key`, `digest`, `hash`
+- **Security: log redaction gaps** — added AWS access key (`AKIA...`), JWT token (`eyJ...`), and SSH/TLS private key header patterns
+- **Security: HTTP bind wildcard** — non-loopback warning now catches `0.0.0.0` and `::` (was only checking 3 specific addresses)
+- **Thread safety: `app_size()` race condition** — `SHARED_CACHE[:context]` read without mutex; now wrapped in `SHARED_CACHE[:mutex].synchronize`
+- **Crash: nil callback filter** — `model_introspector` `cb.filter.to_s` crashed on nil filters; added `cb.filter.nil?` guard
+- **Crash: fingerprinter TOCTOU** — `File.mtime` after `File.exist?` could raise `Errno::ENOENT` if file deleted between calls; added rescue
+- **Crash: tool_runner bounds** — `args[i+1]` access without bounds check; added `i + 1 < args.size` guard
+- **Bug: server logs wrong tool list** — logged all 39 `TOOLS` instead of filtered `active_tools` after `skip_tools`; now shows correct count and names
+- **Bug: STI false positive** — convention detector flagged `Admin < User` as STI even without `type` column; now verifies parent's table has `type` column via schema.rb
+- **Bug: resources bare raise** — `raise "Unknown resource"` changed to `raise RailsAiContext::Error`
+- **Config validation** — `http_port` (1-65535), `cache_ttl` (> 0), `max_tool_response_chars` (> 0), `query_row_limit` (1-1000) now validated on assignment
+
+### Changed
+- Test count: 1529 (unchanged — all new features tested via integration test against sample app)
+
 ## [4.3.3] — 2026-04-02
 
 ### Fixed

data/CLAUDE.md

@@ -56,6 +56,8 @@ structure to AI assistants via the Model Context Protocol (MCP).
 29. **Docs search** — bundled topic index with weighted keyword search, on-demand GitHub fetch
 30. **Safe SQL queries** — defense-in-depth: regex pre-filter + SET TRANSACTION READ ONLY + timeout
 31. **Log reading** — reverse file tail with level filtering and sensitive data redaction
+32. **Config validation** — `http_port`, `cache_ttl`, `max_tool_response_chars`, `query_row_limit` validated on assignment with clear error messages
+33. **Sensitive column redaction** — query tool redacts columns by name AND by suffix pattern (password, secret, token, key, digest, hash) to prevent alias bypass
 
 ## Testing
 

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -178,7 +178,7 @@ module RailsAiContext
                 next
               end
 
-              value = args[i + 1]
+              value = (i + 1 < args.size) ? args[i + 1] : nil
               if value && !value.start_with?("--")
                 result[key] = coerce_value(value, prop)
                 i += 2

data/lib/rails_ai_context/configuration.rb

@@ -198,5 +198,29 @@ module RailsAiContext
     def output_dir_for(app)
       @output_dir || app.root.to_s
     end
+
+    def http_port=(value)
+      value = value.to_i
+      raise ArgumentError, "http_port must be between 1 and 65535 (got #{value})" unless value.between?(1, 65535)
+      @http_port = value
+    end
+
+    def cache_ttl=(value)
+      value = value.to_i
+      raise ArgumentError, "cache_ttl must be positive (got #{value})" unless value > 0
+      @cache_ttl = value
+    end
+
+    def max_tool_response_chars=(value)
+      value = value.to_i
+      raise ArgumentError, "max_tool_response_chars must be positive (got #{value})" unless value > 0
+      @max_tool_response_chars = value
+    end
+
+    def query_row_limit=(value)
+      value = value.to_i
+      raise ArgumentError, "query_row_limit must be between 1 and 1000 (got #{value})" unless value.between?(1, 1000)
+      @query_row_limit = value
+    end
   end
 end

data/lib/rails_ai_context/fingerprinter.rb

@@ -50,6 +50,8 @@ module RailsAiContext
         WATCHED_FILES.each do |file|
           path = File.join(root, file)
           digest.update(File.mtime(path).to_f.to_s) if File.exist?(path)
+        rescue Errno::ENOENT
+          # File deleted between exist? check and mtime read — skip
         end
 
         WATCHED_DIRS.each do |dir|
@@ -58,6 +60,8 @@ module RailsAiContext
 
           Dir.glob(File.join(full_dir, "**/*.{rb,rake,js,ts,erb,haml,slim,yml}")).sort.each do |path|
             digest.update(File.mtime(path).to_f.to_s)
+          rescue Errno::ENOENT
+            # File deleted between glob and mtime read — skip
           end
         end
 

data/lib/rails_ai_context/introspectors/accessibility_introspector.rb

@@ -21,6 +21,10 @@ module RailsAiContext
           images: analyze_images(views),
           labels: analyze_labels(views),
           landmarks: extract_landmarks(views),
+          heading_hierarchy: analyze_heading_hierarchy(views),
+          skip_links: detect_skip_links(views),
+          live_regions: count_live_regions(views),
+          form_inputs: analyze_form_inputs(views),
           summary: build_summary(views)
         }
       rescue => e
@@ -150,6 +154,52 @@ module RailsAiContext
         landmarks
       end
 
+      def analyze_heading_hierarchy(views)
+        all_content = views.map { |v| v[:content] }.join("\n")
+        counts = {}
+        (1..6).each do |level|
+          count = all_content.scan(/<h#{level}[\s>]/i).size
+          counts["h#{level}"] = count if count > 0
+        end
+        counts
+      rescue => e
+        $stderr.puts "[rails-ai-context] analyze_heading_hierarchy failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
+      def detect_skip_links(views)
+        all_content = views.map { |v| v[:content] }.join("\n")
+        {
+          skip_to_content: all_content.scan(/skip.to.(?:content|main)/i).size > 0,
+          skip_navigation: all_content.scan(/skip.nav/i).size > 0
+        }
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_skip_links failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
+      def count_live_regions(views)
+        all_content = views.map { |v| v[:content] }.join("\n")
+        {
+          aria_live: all_content.scan(/aria-live=["'](\w+)["']/).flatten.tally,
+          aria_atomic: all_content.scan(/aria-atomic=/).size
+        }
+      rescue => e
+        $stderr.puts "[rails-ai-context] count_live_regions failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
+      def analyze_form_inputs(views)
+        all_content = views.map { |v| v[:content] }.join("\n")
+        {
+          required: all_content.scan(/\brequired\b/).size,
+          input_types: all_content.scan(/type=["'](\w+)["']/).flatten.tally
+        }
+      rescue => e
+        $stderr.puts "[rails-ai-context] analyze_form_inputs failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
       def build_summary(views)
         all_content = views.map { |v| v[:content] }.join("\n")
 

data/lib/rails_ai_context/introspectors/action_mailbox_introspector.rb

@@ -40,7 +40,14 @@ module RailsAiContext
             { pattern: match[0], action: match[1] }
           end
 
-          { name: name, file: relative, routing: routing }
+          # Extract callbacks
+          callbacks = content.scan(/\b(before_processing|after_processing|around_processing)\s+:(\w+)/).map do |type, method|
+            { type: type, method: method }
+          end
+
+          entry = { name: name, file: relative, routing: routing }
+          entry[:callbacks] = callbacks if callbacks.any?
+          entry
         rescue => e
           $stderr.puts "[rails-ai-context] extract_mailboxes failed: #{e.message}" if ENV["DEBUG"]
           nil

data/lib/rails_ai_context/introspectors/action_text_introspector.rb

@@ -13,7 +13,8 @@ module RailsAiContext
       def call
         {
           installed: defined?(ActionText) ? true : false,
-          rich_text_fields: extract_rich_text_fields
+          rich_text_fields: extract_rich_text_fields,
+          trix_customizations: detect_trix_customizations
         }
       rescue => e
         { error: e.message }
@@ -25,6 +26,24 @@ module RailsAiContext
         app.root.to_s
       end
 
+      def detect_trix_customizations
+        customs = []
+        js_dirs = [ File.join(app.root, "app", "javascript"), File.join(app.root, "app", "assets", "javascripts") ]
+        js_dirs.each do |dir|
+          next unless Dir.exist?(dir)
+          Dir.glob(File.join(dir, "**", "*.{js,ts}")).each do |path|
+            content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+            customs << "custom_toolbar" if content.match?(/Trix\.config\.toolbar/)
+            customs << "custom_attachment" if content.match?(/trix-attachment|Trix\.Attachment/)
+            customs << "custom_editor" if content.match?(/trix-initialize|trix-change/)
+          end
+        end
+        customs.uniq
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_trix_customizations failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
       def extract_rich_text_fields
         models_dir = File.join(root, "app/models")
         return [] unless Dir.exist?(models_dir)

data/lib/rails_ai_context/introspectors/active_storage_introspector.rb

@@ -16,7 +16,9 @@ module RailsAiContext
           installed: defined?(ActiveStorage) ? true : false,
           attachments: extract_attachments,
           storage_services: extract_storage_services,
-          direct_upload: detect_direct_upload
+          direct_upload: detect_direct_upload,
+          validations: extract_attachment_validations,
+          variants: extract_variants
         }
       rescue => e
         { error: e.message }
@@ -64,6 +66,47 @@ module RailsAiContext
         []
       end
 
+      def extract_attachment_validations
+        validations = []
+        models_dir = File.join(app.root, "app", "models")
+        return validations unless Dir.exist?(models_dir)
+
+        Dir.glob(File.join(models_dir, "**", "*.rb")).each do |path|
+          content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+          model = File.basename(path, ".rb").camelize
+          content.each_line do |line|
+            if (match = line.match(/validates?\s+:(\w+),.*content_type:/))
+              validations << { model: model, attachment: match[1], type: "content_type" }
+            end
+            if (match = line.match(/validates?\s+:(\w+),.*size:/))
+              validations << { model: model, attachment: match[1], type: "size" }
+            end
+          end
+        end
+        validations
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_attachment_validations failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
+      def extract_variants
+        variants = []
+        models_dir = File.join(app.root, "app", "models")
+        return variants unless Dir.exist?(models_dir)
+
+        Dir.glob(File.join(models_dir, "**", "*.rb")).each do |path|
+          content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+          model = File.basename(path, ".rb").camelize
+          content.scan(/\.variant\s*\(\s*:(\w+)/).each do |name|
+            variants << { model: model, name: name[0] }
+          end
+        end
+        variants
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_variants failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
       def detect_direct_upload
         views_dir = File.join(root, "app/views")
         js_dir = File.join(root, "app/javascript")

data/lib/rails_ai_context/introspectors/api_introspector.rb

@@ -20,7 +20,9 @@ module RailsAiContext
           rate_limiting: detect_rate_limiting,
           openapi_spec: detect_openapi_specs,
           cors_config: detect_cors_config,
-          api_client_generation: detect_api_client_generation
+          api_client_generation: detect_api_client_generation,
+          graphql_details: extract_graphql_details,
+          pagination: detect_pagination
         }
       rescue => e
         { error: e.message }
@@ -118,6 +120,36 @@ module RailsAiContext
         []
       end
 
+      def extract_graphql_details
+        graphql_dir = File.join(app.root, "app", "graphql")
+        return nil unless Dir.exist?(graphql_dir)
+
+        details = {}
+        details[:resolvers] = Dir.glob(File.join(graphql_dir, "**", "*resolver*")).map { |f| File.basename(f, ".rb").camelize }
+        details[:subscriptions] = Dir.glob(File.join(graphql_dir, "**", "subscriptions", "*.rb")).map { |f| File.basename(f, ".rb").camelize }
+        details[:dataloaders] = Dir.glob(File.join(graphql_dir, "**", "{loaders,dataloaders}", "*.rb")).map { |f| File.basename(f, ".rb").camelize }
+        details.reject { |_, v| v.empty? }
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_graphql_details failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
+      def detect_pagination
+        gemfile_lock = File.join(app.root, "Gemfile.lock")
+        return nil unless File.exist?(gemfile_lock)
+        content = File.read(gemfile_lock)
+
+        strategies = []
+        strategies << "pagy" if content.include?("pagy")
+        strategies << "kaminari" if content.include?("kaminari")
+        strategies << "will_paginate" if content.include?("will_paginate")
+        strategies << "cursor" if content.include?("graphql-pro") # cursor-based pagination
+        strategies.empty? ? nil : strategies
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_pagination failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
       def detect_rate_limiting
         # Rack::Attack
         init_path = File.join(root, "config/initializers/rack_attack.rb")

data/lib/rails_ai_context/introspectors/asset_pipeline_introspector.rb

@@ -51,14 +51,17 @@ module RailsAiContext
         lock_content = read_gemfile_lock
         return nil unless lock_content
 
-        return "tailwindcss" if lock_content.include?("tailwindcss-rails (")
+        return "tailwindcss" if lock_content.include?("tailwindcss-rails (") || package_json_has?("tailwindcss")
         return "bootstrap" if lock_content.include?("bootstrap (") || package_json_has?("bootstrap")
         return "bulma" if package_json_has?("bulma")
+        return "foundation" if package_json_has?("foundation-sites")
+        return "postcss" if package_json_has?("postcss") && !package_json_has?("tailwindcss")
         nil
       end
 
       def detect_js_bundler
         return "importmap" if File.exist?(File.join(root, "config/importmap.rb"))
+        return "bun" if File.exist?(File.join(root, "bun.lockb")) || File.exist?(File.join(root, "bunfig.toml"))
         return "esbuild" if package_json_has?("esbuild")
         return "webpack" if File.exist?(File.join(root, "config/webpack")) || package_json_has?("webpack")
         return "vite" if Dir.glob(File.join(root, "vite.config.*")).any?

data/lib/rails_ai_context/introspectors/auth_introspector.rb

@@ -45,6 +45,14 @@ module RailsAiContext
         secure_pw = scan_models_for(/has_secure_password/)
         auth[:has_secure_password] = secure_pw.map { |m| m[:model] } if secure_pw.any?
 
+        # OmniAuth providers
+        omniauth = detect_omniauth_providers
+        auth[:omniauth_providers] = omniauth if omniauth.any?
+
+        # Devise settings (timeout, lockout, etc.)
+        devise_settings = extract_devise_settings
+        auth[:devise_settings] = devise_settings unless devise_settings.empty?
+
         auth
       end
 
@@ -173,6 +181,46 @@ module RailsAiContext
         []
       end
 
+      def detect_omniauth_providers
+        providers = []
+        initializers = Dir.glob(File.join(app.root, "config", "initializers", "*.rb"))
+        initializers.each do |path|
+          content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+          content.scan(/config\.omniauth\s+:(\w+)/).each { |m| providers << m[0] }
+          content.scan(/provider\s+:(\w+)/).each { |m| providers << m[0] unless %w[developer].include?(m[0]) }
+        end
+        # Also check model files for omniauth_providers
+        models_dir = File.join(app.root, "app", "models")
+        if Dir.exist?(models_dir)
+          Dir.glob(File.join(models_dir, "**", "*.rb")).each do |path|
+            content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+            content.scan(/omniauth_providers:\s*\[([^\]]+)\]/).each do |m|
+              m[0].scan(/:(\w+)/).each { |p| providers << p[0] }
+            end
+          end
+        end
+        providers.uniq
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_omniauth_providers failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
+      def extract_devise_settings
+        path = File.join(app.root, "config", "initializers", "devise.rb")
+        return {} unless File.exist?(path)
+        content = File.read(path)
+        settings = {}
+        settings[:timeout_in] = $1 if content.match(/config\.timeout_in\s*=\s*(\S+)/)
+        settings[:lock_strategy] = $1 if content.match(/config\.lock_strategy\s*=\s*:(\w+)/)
+        settings[:maximum_attempts] = $1.to_i if content.match(/config\.maximum_attempts\s*=\s*(\d+)/)
+        settings[:unlock_strategy] = $1 if content.match(/config\.unlock_strategy\s*=\s*:(\w+)/)
+        settings[:password_length] = $1 if content.match(/config\.password_length\s*=\s*(\S+)/)
+        settings.empty? ? {} : settings
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_devise_settings failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
       def scan_models_for(pattern)
         models_dir = File.join(root, "app/models")
         return [] unless Dir.exist?(models_dir)

data/lib/rails_ai_context/introspectors/component_introspector.rb

@@ -150,6 +150,12 @@ module RailsAiContext
           props << prop
         end
 
+        # Detect **kwargs / **options splat
+        if params_str.match?(/\*\*(\w+)/)
+          splat_name = params_str.match(/\*\*(\w+)/)[1]
+          props << { name: splat_name, splat: true }
+        end
+
         props
       end
 

data/lib/rails_ai_context/introspectors/config_introspector.rb

@@ -12,7 +12,7 @@ module RailsAiContext
       end
 
       def call
-        {
+        result = {
           cache_store: detect_cache_store,
           session_store: detect_session_store,
           timezone: app.config.time_zone.to_s,
@@ -21,8 +21,19 @@ module RailsAiContext
           middleware_stack: extract_middleware,
           initializers: extract_initializers,
           credentials_configured: credentials_configured?,
-          current_attributes: detect_current_attributes
-        }.compact
+          current_attributes: detect_current_attributes,
+          error_monitoring: detect_error_monitoring,
+          job_processor: detect_job_processor_config
+        }
+
+        # Extract cache store options when configured as an Array
+        if app.config.cache_store.is_a?(Array) && app.config.cache_store.size > 1
+          opts = app.config.cache_store[1..]
+          cache_opts = opts.last.is_a?(Hash) ? opts.last.keys.map(&:to_s) : []
+          result[:cache_store_options] = cache_opts if cache_opts.any?
+        end
+
+        result.compact
       rescue => e
         { error: e.message }
       end
@@ -123,6 +134,39 @@ module RailsAiContext
           nil
         end
       end
+
+      def detect_error_monitoring
+        gemfile_lock = File.join(app.root, "Gemfile.lock")
+        return nil unless File.exist?(gemfile_lock)
+        content = File.read(gemfile_lock)
+
+        tools = []
+        tools << "sentry" if content.include?("sentry-ruby") || content.include?("sentry-rails")
+        tools << "bugsnag" if content.include?("bugsnag")
+        tools << "honeybadger" if content.include?("honeybadger")
+        tools << "rollbar" if content.include?("rollbar")
+        tools << "airbrake" if content.include?("airbrake")
+        tools << "appsignal" if content.include?("appsignal")
+        tools.empty? ? nil : tools
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_error_monitoring failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
+      def detect_job_processor_config
+        config = {}
+        sidekiq_path = File.join(app.root, "config", "sidekiq.yml")
+        if File.exist?(sidekiq_path)
+          content = File.read(sidekiq_path)
+          config[:processor] = "sidekiq"
+          config[:concurrency] = $1.to_i if content.match(/concurrency:\s*(\d+)/)
+          config[:queues] = content.scan(/-\s+(\w+)/).flatten.uniq
+        end
+        config.empty? ? nil : config
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_job_processor_config failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
     end
   end
 end

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -86,7 +86,8 @@ module RailsAiContext
       def extract_details_from_source(path)
         source = File.read(path)
         parent = source.match(/class\s+\S+\s*<\s*(\S+)/)&.send(:[], 1) || "Unknown"
-        {
+        rate_limit_raw = extract_rate_limit(source)
+        details = {
           parent_class: parent,
           api_controller: parent.include?("API"),
           actions: extract_actions_from_source(source),
@@ -95,15 +96,18 @@ module RailsAiContext
           strong_params: extract_strong_params(source),
           respond_to_formats: extract_respond_to(source),
           rescue_from: extract_rescue_from(source),
-          rate_limit: extract_rate_limit(source),
+          rate_limit: rate_limit_raw,
+          rate_limit_parsed: parse_rate_limit(rate_limit_raw),
           turbo_stream_actions: extract_turbo_stream_actions(source)
         }.compact
+        details
       rescue => e
         { error: e.message }
       end
 
       def extract_controller_details(ctrl)
         source = read_source(ctrl)
+        rate_limit_raw = extract_rate_limit(source)
 
         {
           parent_class: ctrl.superclass.name,
@@ -114,7 +118,8 @@ module RailsAiContext
           strong_params: extract_strong_params(source),
           respond_to_formats: extract_respond_to(source),
           rescue_from: extract_rescue_from(source),
-          rate_limit: extract_rate_limit(source),
+          rate_limit: rate_limit_raw,
+          rate_limit_parsed: parse_rate_limit(rate_limit_raw),
           turbo_stream_actions: extract_turbo_stream_actions(source)
         }.compact
       end
@@ -150,6 +155,9 @@ module RailsAiContext
 
           next if in_private
 
+          # Skip inline private/protected method definitions (e.g. `private def foo`)
+          next if line.match?(/\A\s*(?:private|protected)\s+def\s/)
+
           if (match = line.match(/\A\s*def\s+(\w+[?!]?)/))
             actions << match[1] unless match[1].start_with?("_")
           end
@@ -361,6 +369,20 @@ module RailsAiContext
         nil
       end
 
+      def parse_rate_limit(rate_limit_raw)
+        return nil if rate_limit_raw.nil?
+
+        parsed = {}
+        parsed[:to] = $1.to_i if rate_limit_raw.match(/to:\s*(\d+)/)
+        parsed[:within] = $1 if rate_limit_raw.match(/within:\s*(\S+)/)
+        parsed[:only] = $1.scan(/:(\w+)/).flatten if rate_limit_raw.match(/only:\s*(.+?)(?:,\s*\w+:|$)/)
+
+        parsed.empty? ? nil : parsed
+      rescue => e
+        $stderr.puts "[rails-ai-context] parse_rate_limit failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
       def extract_turbo_stream_actions(source)
         return [] if source.nil?
         return [] unless source.match?(/format\.turbo_stream|\.turbo_stream\.erb/)

data/lib/rails_ai_context/introspectors/convention_detector.rb

@@ -58,6 +58,11 @@ module RailsAiContext
         %w[dry-validation dry-types dry-struct dry-monads].each do |gem|
           arch << "dry_rb" if gem_present?(gem)
         end
+        arch << "multi_tenant" if gem_present?("apartment") || gem_present?("acts_as_tenant") || gem_present?("ros-apartment")
+        arch << "feature_flags" if gem_present?("flipper") || gem_present?("launchdarkly-server-sdk") || gem_present?("split") || gem_present?("unleash")
+        arch << "error_monitoring" if gem_present?("sentry-ruby") || gem_present?("bugsnag") || gem_present?("honeybadger") || gem_present?("rollbar") || gem_present?("airbrake")
+        arch << "event_driven" if gem_present?("ruby-kafka") || gem_present?("karafka") || gem_present?("bunny") || gem_present?("sneakers") || gem_present?("aws-sdk-sns") || gem_present?("aws-sdk-sqs")
+        arch << "zeitwerk" if defined?(Zeitwerk) && defined?(Rails) && Rails.autoloaders.respond_to?(:main)
         arch.uniq
       end
 
@@ -70,7 +75,24 @@ module RailsAiContext
           model_files = Dir.glob(File.join(model_dir, "**/*.rb"))
           content = model_files.first(500).map { |f| File.read(f) rescue "" }.join("\n")
 
-          patterns << "sti" if content.match?(/self\.inheritance_column|type.*string/)
+          # STI: explicit inheritance_column, or a model that inherits from another app model
+          # with a `type` column (verified via schema.rb or model source)
+          app_model_names = model_files.filter_map { |f| File.basename(f, ".rb").camelize }
+          schema_content = begin
+            schema_path = File.join(root, "db/schema.rb")
+            File.exist?(schema_path) ? File.read(schema_path) : ""
+          rescue
+            ""
+          end
+          has_sti_subclass = model_files.any? do |f|
+            src = File.read(f) rescue ""
+            parent_match = src.match(/class\s+\w+\s*<\s*(\w+)/)
+            next false unless parent_match && app_model_names.include?(parent_match[1]) && parent_match[1] != "ApplicationRecord"
+            # Verify parent's table has a `type` column
+            parent_table = parent_match[1].underscore.pluralize
+            schema_content.match?(/create_table\s+"#{Regexp.escape(parent_table)}".*?t\.\w+\s+"type"/m)
+          end
+          patterns << "sti" if content.match?(/self\.inheritance_column/) || has_sti_subclass
           patterns << "polymorphic" if content.match?(/polymorphic:\s*true/)
           patterns << "soft_delete" if content.match?(/acts_as_paranoid|discard|deleted_at/)
           patterns << "versioning" if content.match?(/has_paper_trail|audited/)