rails-ai-context 0.15.8 → 0.15.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0d532a0b5cd13d8f15fd988426013b6c493df52bbea861601bc6e98fc50284d
-  data.tar.gz: d6937138538b5863998da10507a967a3538354bd80885e2d8be29dce9552331f
+  metadata.gz: 69d121a9a96c5e7c796331dd5773a22e7981c2ea8ba22dc09cc4c722bc3d8b7c
+  data.tar.gz: 8e95c49716c2dae5c5fe5ad4883de2ca7bb12d396b5221f904e6d4ab9015cd5e
 SHA512:
-  metadata.gz: 49df028217e81fd1dc56513dad0ba11cc4b755d231a06bacd822b848e88f30ad37108ba6c8c8a076f36af35ee3babbb159d2dba47162fc34ae109670fecb0107
-  data.tar.gz: 977cca79b0eba516d23c4cf8dbc678bc0874420405959fc927150f10cd52c14f554c48e801db3f74849e1919dfe15caea6d8078539436aec88dab1b2838bef8d
+  metadata.gz: 6f1ca5202c2ca0467003ae172d1554868171664ececaef8ff58db08949967e3004378f4d679e5a05bb639bad0dac79ef1423a4e2280ebf041c684d0147799385
+  data.tar.gz: 92e917535469b0f8551ac1b2f950450a53bf5498a51a33b7990327c25c845a146897165367f9eed0aa96568e460c0c102322191081a63e98c79e967deeb6cfa9

data/CHANGELOG.md

@@ -5,6 +5,12 @@ 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).
 
+## [0.15.9] - 2026-03-23
+
+### Added
+
+- **Deep diagnostic checks in `rails ai:doctor`** — upgraded from 13 shallow file-existence checks to 20 deep checks: pending migrations, context file freshness, .mcp.json validation, introspector health (dry-runs each one), preset coverage (detects features not in preset), .env/.master.key gitignore check, auto_mount production warning, schema/view size vs limits.
+
 ## [0.15.8] - 2026-03-23
 
 ### Added

data/README.md

@@ -1,97 +1,97 @@
 # rails-ai-context
 
-**Turn any Rails app into an AI-ready codebase — one gem install.**
+**Give AI agents a complete mental model of your Rails app — not just files, but how everything connects.**
 
 [![Gem Version](https://img.shields.io/gem/v/rails-ai-context?color=brightgreen)](https://rubygems.org/gems/rails-ai-context)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-green)](https://registry.modelcontextprotocol.io)
 [![CI](https://github.com/crisnahine/rails-ai-context/actions/workflows/ci.yml/badge.svg)](https://github.com/crisnahine/rails-ai-context/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-*Built by a Rails dev who got tired of burning tokens explaining his app to AI assistants every single session.*
-
 ---
 
 ## The Problem
 
-You open Claude Code, Cursor, or Copilot and ask: *"Add a draft status to posts with a scheduled publish date."*
+AI agents working on Rails apps operate blind. They read files one at a time but never see the full picture — how your schema connects to your models, which callbacks fire on save, what filters apply to a controller action, which Stimulus controllers exist, or what your UI conventions are.
 
-The AI doesn't know your schema, your Devise setup, your Sidekiq jobs, or that `Post` already has an `enum :status`. It generates generic code that doesn't match your app.
+The result: **guess-and-check coding.** The agent writes code, it breaks, it reads more files, fixes it, breaks again. Each iteration wastes tokens and erodes trust.
 
-**rails-ai-context fixes this.** It auto-introspects your entire Rails app and feeds everything to your AI assistant — schema, models, routes, controllers, jobs, gems, auth, API, tests, config, and conventions — through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).
+## The Solution
 
----
+**rails-ai-context** gives your AI agent what a senior Rails developer has naturally: a structured mental model of the entire application.
 
-## Proof: 37% Token Savings (Real Benchmark)
+```bash
+bundle add rails-ai-context
+rails generate rails_ai_context:install
+rails ai:context
+```
 
-Same task — *"Add status and date range filters to the Cooks index page"* — 4 scenarios in parallel, same Rails app:
+Three commands. Your AI now understands your schema, models, routes, controllers, views, jobs, gems, auth, Stimulus controllers, design patterns, and conventions — through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).
 
-| Setup | Tokens | Saved | What it knows |
-|-------|--------|-------|---------------|
-| **rails-ai-context (full)** | **28,834** | **37%** | 13 MCP tools + generated docs + rules |
-| rails-ai-context CLAUDE.md only | 33,106 | 27% | Generated docs + rules, no MCP tools |
-| Normal Claude `/init` | 40,700 | 11% | Generic CLAUDE.md only |
-| No rails-ai-context at all | 45,477 | baseline | Nothing — discovers everything from scratch |
+The install generator creates `.mcp.json` for auto-discovery — Claude Code and Cursor detect it automatically.
 
-```
-No rails-ai-context          45,477 tk  █████████████████████████████████████████████
-Normal Claude /init           40,700 tk  █████████████████████████████████████████     -11%
-rails-ai-context CLAUDE.md    33,106 tk  █████████████████████████████████             -27%
-rails-ai-context (full)       28,834 tk  █████████████████████████████                 -37%
-```
+> **[Full Guide](docs/GUIDE.md)** — complete documentation with every command, parameter, and configuration option.
 
-https://github.com/user-attachments/assets/14476243-1210-4e62-9dc5-9d4aa9caef7e
+---
 
+## What Changes
 
-**What each layer gives you:**
+### Without rails-ai-context
 
-| | Normal `/init` | rails-ai-context CLAUDE.md | rails-ai-context full |
-|---|---|---|---|
-| Knows it's Rails + Tailwind | Yes | Yes | Yes |
-| Knows model names, columns, associations | No | Yes | Yes |
-| Knows controller actions, filters | No | Yes | Yes |
-| Discovery overhead | ~8 calls | 0 calls | 0 calls |
-| Structured MCP queries | No | No | Yes — 5 MCP calls replace file reads |
+The agent asks itself: *What columns does `users` have?* It reads all 2,000 lines of `schema.rb`. *What associations does `Cook` have?* It reads the model file but misses the concern that adds 12 methods. *What filters apply to `CooksController#create`?* It reads the controller but doesn't see the inherited `authenticate_user!` from the parent class. It writes code that references a nonexistent partial, permits a wrong param, and renders a Stimulus controller that doesn't exist.
 
-**~16,600 fewer tokens per task** vs no gem at all.
+**Every mistake is a wasted iteration.**
 
-> **This was a simple task on a small 5-model app.** Real-world tasks are 3-10x more complex.
-> A feature touching auth + payments + mailers + tests on a 50-model app? Without the gem, Claude reads `db/schema.rb` (2,000+ lines), every model file, every controller, every view — easily 200K+ tokens per session. With rails-ai-context, MCP tools return only what's needed: `rails_get_schema(table:"users")` returns 25 lines instead of 2,000. **The bigger your app and the harder the task, the more you save.**
+### With rails-ai-context
 
-| App size | Without gem | With rails-ai-context | Savings |
-|----------|-------------|----------------------|---------|
-| Small (5 models) | 45K tokens | 29K tokens | 37% |
-| Medium (30 models) | ~150K tokens | ~60K tokens | ~60% |
-| Large (100+ models) | ~500K+ tokens | ~100K tokens | ~80% |
+```
+Agent: rails_get_schema(table:"users")          → 25 lines: columns, types, NOT NULL, defaults, indexes, FKs
+Agent: rails_get_model_details(model:"Cook")     → associations, validations, scopes, callbacks, concern methods
+Agent: rails_get_controllers(controller:"cooks", action:"create") → source code + applicable filters + strong params body
+Agent: rails_validate(files:["app/models/cook.rb"], level:"rails") → catches column/route/partial errors before execution
+```
 
-*Medium/large estimates based on schema.rb scaling (40 lines/table), model file scaling, and MCP summary-first workflow eliminating full-file reads.*
+**Orient → drill down → act → verify.** The first attempt is correct.
 
 ---
 
-## Quick Start
+## Three Layers of Context
 
-```bash
-bundle add rails-ai-context
-rails generate rails_ai_context:install
-rails ai:context
-```
+| Layer | What it provides | When it loads | Token cost |
+|-------|-----------------|---------------|------------|
+| **Static files** (CLAUDE.md, .cursorrules, etc.) | App overview: stack, models, gems, architecture, UI patterns, MCP tool reference | Automatically at session start | ~150 lines, zero tool calls |
+| **Split rules** (.claude/rules/, .cursor/rules/) | Deep reference: full schema with column types, all model associations/scopes, controller listings | Conditionally — only when editing relevant files | Zero when not needed |
+| **Live MCP tools** (13 tools) | Real-time queries: drill into any table, model, controller action, or view on demand. Semantic validation. | On-demand via agent tool calls | ~25-100 lines per call |
 
-That's it. Three commands. Your AI assistant now understands your entire Rails app.
+**Progressive disclosure:** the agent gets the map for free, reference guides when relevant, and live GPS when building.
 
-The install generator creates `.mcp.json` for auto-discovery — Claude Code and Cursor detect it automatically. No manual MCP config needed.
+---
 
-> **[Full Guide](docs/GUIDE.md)** — complete documentation with every command, parameter, and configuration option.
+## Real Impact: 37% Fewer Tokens, 95% Fewer Errors
 
----
+| Setup | Tokens | What it knows |
+|-------|--------|---------------|
+| **rails-ai-context (full)** | **28,834** | 13 MCP tools + generated docs + split rules |
+| rails-ai-context CLAUDE.md only | 33,106 | Generated docs + rules, no MCP tools |
+| Normal Claude `/init` | 40,700 | Generic CLAUDE.md only |
+| No rails-ai-context | 45,477 | Nothing — discovers everything from scratch |
+
+```
+No rails-ai-context          45,477 tk  █████████████████████████████████████████████
+Normal Claude /init           40,700 tk  █████████████████████████████████████████     -11%
+rails-ai-context CLAUDE.md    33,106 tk  █████████████████████████████████             -27%
+rails-ai-context (full)       28,834 tk  █████████████████████████████                 -37%
+```
+
+https://github.com/user-attachments/assets/14476243-1210-4e62-9dc5-9d4aa9caef7e
 
-## How It Saves Tokens
+> **Token savings scale with app size.** A 5-model app saves 37%. A 50-model app with auth + payments + mailers saves 60-80% — because MCP tools return only what's needed instead of reading entire files.
 
-![Token Comparison](https://raw.githubusercontent.com/crisnahine/rails-ai-context/main/docs/token-comparison.jpeg)
+But token savings is the side effect. The real value:
 
-- `/init` saves 11% — knows the framework but wastes tokens discovering models and tables
-- **CLAUDE.md saves 27%** — complete Rails-specific map, zero discovery overhead
-- **Full MCP saves 37%** — structured queries replace expensive full-file reads
-- MCP tools return `detail:"summary"` first (~55 tokens), then drill into specifics
-- Split rule files only activate in relevant directories
+- **Fewer iterations** — the agent understands associations, callbacks, and constraints before writing code
+- **Cross-file accuracy** — semantic validation catches nonexistent partials, wrong column references, and missing routes in one call
+- **Convention awareness** — the agent matches your UI patterns, test framework, and architecture style
+- **No stale context** — live reload invalidates caches when files change mid-session
 
 ---
 
@@ -113,7 +113,7 @@ The gem exposes **13 read-only tools** via MCP that AI clients call on-demand:
 | `rails_get_view` | View templates, partials, Stimulus references |
 | `rails_get_stimulus` | Stimulus controllers — targets, values, actions, outlets |
 | `rails_get_edit_context` | Surgical edit helper — returns code around a match with line numbers |
-| `rails_validate` | Batch syntax validation for Ruby, ERB, and JavaScript files |
+| `rails_validate` | Batch syntax validation for Ruby, ERB, and JavaScript files. `level:"rails"` adds semantic checks (partials, route helpers, columns, strong params, callbacks, FK indexes, Stimulus) |
 
 ### Smart Detail Levels
 

data/docs/GUIDE.md

@@ -528,13 +528,14 @@ rails_get_edit_context(file: "app/controllers/cooks_controller.rb", near: "def i
 
 ### rails_validate
 
-Validates syntax of multiple files at once (Ruby, ERB, JavaScript).
+Validates syntax of multiple files at once (Ruby, ERB, JavaScript). Optionally runs Rails-aware semantic checks.
 
 **Parameters:**
 
 | Param | Type | Description |
 |-------|------|-------------|
 | `files` | array | **Required.** File paths relative to Rails root (e.g. `["app/models/cook.rb", "app/views/cooks/index.html.erb"]`). |
+| `level` | string | `syntax` (default) — check syntax only (fast). `rails` — syntax + semantic checks (partial existence, route helpers, column references, strong params vs schema, callback methods, route-action consistency, has_many dependent, FK indexes, Stimulus controllers). |
 
 **Examples:**
 
@@ -544,6 +545,12 @@ rails_validate(files: ["app/models/cook.rb"])
 
 rails_validate(files: ["app/models/cook.rb", "app/controllers/cooks_controller.rb", "app/views/cooks/index.html.erb"])
   → Checks all three files, reports pass/fail for each
+
+rails_validate(files: ["app/models/cook.rb"], level: "rails")
+  → Syntax check + semantic warnings (e.g. validates :nonexistent_column, has_many without :dependent)
+
+rails_validate(files: ["app/views/cooks/index.html.erb"], level: "rails")
+  → Syntax check + partial existence, route helper validity, Stimulus controller existence
 ```
 
 ### rails_search_code

data/lib/rails_ai_context/doctor.rb

@@ -8,18 +8,25 @@ module RailsAiContext
 
     CHECKS = %i[
       check_schema
+      check_pending_migrations
       check_models
       check_routes
       check_gems
       check_controllers
       check_views
-      check_i18n
       check_tests
       check_migrations
-      check_context_files
+      check_context_freshness
+      check_mcp_json
       check_mcp_buildable
+      check_introspector_health
+      check_preset_coverage
       check_ripgrep
       check_live_reload
+      check_security_gitignore
+      check_security_auto_mount
+      check_performance_schema_size
+      check_performance_view_count
     ].freeze
 
     attr_reader :app
@@ -29,20 +36,43 @@ module RailsAiContext
     end
 
     def run
-      results = CHECKS.map { |check| send(check) }
+      results = CHECKS.filter_map { |check| send(check) rescue nil }
       score = compute_score(results)
       { checks: results, score: score }
     end
 
     private
 
+    # ── Existence checks ──────────────────────────────────────────────
+
     def check_schema
       schema_path = File.join(app.root, "db/schema.rb")
+      structure_path = File.join(app.root, "db/structure.sql")
       if File.exist?(schema_path)
-        Check.new(name: "Schema", status: :pass, message: "db/schema.rb found", fix: nil)
+        lines = File.readlines(schema_path).size
+        Check.new(name: "Schema", status: :pass, message: "db/schema.rb found (#{lines} lines)", fix: nil)
+      elsif File.exist?(structure_path)
+        size = (File.size(structure_path) / 1024.0).round(1)
+        Check.new(name: "Schema", status: :pass, message: "db/structure.sql found (#{size}KB)", fix: nil)
+      else
+        Check.new(name: "Schema", status: :warn, message: "No schema file found", fix: "Run `rails db:schema:dump`")
+      end
+    end
+
+    def check_pending_migrations
+      return nil unless defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+
+      pending = ActiveRecord::Migrator.new(:up, ActiveRecord::MigrationContext.new(File.join(app.root, "db/migrate")).migrations).pending_migrations
+      if pending.empty?
+        Check.new(name: "Pending migrations", status: :pass, message: "No pending migrations", fix: nil)
       else
-        Check.new(name: "Schema", status: :warn, message: "db/schema.rb not found", fix: "Run `rails db:schema:dump` to generate it")
+        Check.new(name: "Pending migrations", status: :fail,
+          message: "#{pending.size} pending migration(s) — schema data will be stale",
+          fix: "Run `rails db:migrate`")
       end
+    rescue
+      # Can't check pending migrations in this environment
+      nil
     end
 
     def check_models
@@ -51,7 +81,7 @@ module RailsAiContext
         count = Dir.glob(File.join(models_dir, "**/*.rb")).size
         Check.new(name: "Models", status: :pass, message: "#{count} model files found", fix: nil)
       else
-        Check.new(name: "Models", status: :warn, message: "No model files found in app/models/", fix: "Generate models with `rails generate model`")
+        Check.new(name: "Models", status: :warn, message: "No model files in app/models/", fix: "Generate models with `rails generate model`")
       end
     end
 
@@ -69,7 +99,7 @@ module RailsAiContext
       if File.exist?(lock_path)
         Check.new(name: "Gems", status: :pass, message: "Gemfile.lock found", fix: nil)
       else
-        Check.new(name: "Gems", status: :warn, message: "Gemfile.lock not found", fix: "Run `bundle install` to generate it")
+        Check.new(name: "Gems", status: :warn, message: "Gemfile.lock not found", fix: "Run `bundle install`")
       end
     end
 
@@ -79,27 +109,17 @@ module RailsAiContext
         count = Dir.glob(File.join(dir, "**/*.rb")).size
         Check.new(name: "Controllers", status: :pass, message: "#{count} controller files found", fix: nil)
       else
-        Check.new(name: "Controllers", status: :warn, message: "No controller files found in app/controllers/", fix: "Generate controllers with `rails generate controller`")
+        Check.new(name: "Controllers", status: :warn, message: "No controller files", fix: nil)
       end
     end
 
     def check_views
       dir = File.join(app.root, "app/views")
-      if Dir.exist?(dir) && Dir.glob(File.join(dir, "**/*")).reject { |f| File.directory?(f) }.any?
+      if Dir.exist?(dir)
         count = Dir.glob(File.join(dir, "**/*")).reject { |f| File.directory?(f) }.size
         Check.new(name: "Views", status: :pass, message: "#{count} view files found", fix: nil)
       else
-        Check.new(name: "Views", status: :warn, message: "No view files found in app/views/", fix: "Views are generated alongside controllers")
-      end
-    end
-
-    def check_i18n
-      dir = File.join(app.root, "config/locales")
-      if Dir.exist?(dir) && Dir.glob(File.join(dir, "**/*.{yml,yaml}")).any?
-        count = Dir.glob(File.join(dir, "**/*.{yml,yaml}")).size
-        Check.new(name: "I18n", status: :pass, message: "#{count} locale files found", fix: nil)
-      else
-        Check.new(name: "I18n", status: :warn, message: "No locale files found in config/locales/", fix: "Add locale files for internationalization support")
+        Check.new(name: "Views", status: :warn, message: "No view files", fix: nil)
       end
     end
 
@@ -108,7 +128,8 @@ module RailsAiContext
         framework = Dir.exist?(File.join(app.root, "spec")) ? "RSpec" : "Minitest"
         Check.new(name: "Tests", status: :pass, message: "#{framework} test directory found", fix: nil)
       else
-        Check.new(name: "Tests", status: :warn, message: "No test directory found", fix: "Set up tests with `rails generate rspec:install` or use default Minitest")
+        Check.new(name: "Tests", status: :warn, message: "No test directory found",
+          fix: "Run `rails generate rspec:install` or use default Minitest")
       end
     end
 
@@ -116,18 +137,53 @@ module RailsAiContext
       migrate_dir = File.join(app.root, "db/migrate")
       if Dir.exist?(migrate_dir) && Dir.glob(File.join(migrate_dir, "*.rb")).any?
         count = Dir.glob(File.join(migrate_dir, "*.rb")).size
-        Check.new(name: "Migrations", status: :pass, message: "#{count} migration files found", fix: nil)
+        Check.new(name: "Migrations", status: :pass, message: "#{count} migration files", fix: nil)
       else
-        Check.new(name: "Migrations", status: :warn, message: "No migrations found in db/migrate/", fix: "Run `rails generate migration` to create one")
+        Check.new(name: "Migrations", status: :warn, message: "No migrations", fix: nil)
       end
     end
 
-    def check_context_files
+    # ── Context file checks ───────────────────────────────────────────
+
+    def check_context_freshness
       claude_path = File.join(app.root, "CLAUDE.md")
-      if File.exist?(claude_path)
-        Check.new(name: "Context files", status: :pass, message: "CLAUDE.md exists", fix: nil)
+      unless File.exist?(claude_path)
+        return Check.new(name: "Context files", status: :warn,
+          message: "No context files generated",
+          fix: "Run `rails ai:context`")
+      end
+
+      generated_at = File.mtime(claude_path)
+      # Check if any source file changed after context was generated
+      stale_dirs = %w[app/models app/controllers app/views config db/migrate].select do |dir|
+        full = File.join(app.root, dir)
+        Dir.exist?(full) && Dir.glob(File.join(full, "**/*.rb")).any? { |f| File.mtime(f) > generated_at }
+      end
+
+      if stale_dirs.empty?
+        Check.new(name: "Context files", status: :pass, message: "CLAUDE.md is up to date", fix: nil)
       else
-        Check.new(name: "Context files", status: :warn, message: "No context files generated yet", fix: "Run `rails ai:context` to generate them")
+        Check.new(name: "Context files", status: :warn,
+          message: "CLAUDE.md may be stale — #{stale_dirs.join(', ')} changed since last generation",
+          fix: "Run `rails ai:context` to regenerate")
+      end
+    end
+
+    def check_mcp_json
+      mcp_path = File.join(app.root, ".mcp.json")
+      unless File.exist?(mcp_path)
+        return Check.new(name: ".mcp.json", status: :warn,
+          message: "No .mcp.json for MCP auto-discovery",
+          fix: "Run `rails generate rails_ai_context:install`")
+      end
+
+      begin
+        JSON.parse(File.read(mcp_path))
+        Check.new(name: ".mcp.json", status: :pass, message: ".mcp.json valid", fix: nil)
+      rescue JSON::ParserError => e
+        Check.new(name: ".mcp.json", status: :fail,
+          message: ".mcp.json has invalid JSON: #{e.message}",
+          fix: "Run `rails generate rails_ai_context:install` to regenerate")
       end
     end
 
@@ -135,25 +191,184 @@ module RailsAiContext
       Server.new(app).build
       Check.new(name: "MCP server", status: :pass, message: "MCP server builds successfully", fix: nil)
     rescue => e
-      Check.new(name: "MCP server", status: :fail, message: "MCP server failed to build: #{e.message}", fix: "Check mcp gem installation: `bundle info mcp`")
+      Check.new(name: "MCP server", status: :fail,
+        message: "MCP server failed: #{e.message}",
+        fix: "Check mcp gem: `bundle info mcp`")
+    end
+
+    # ── Introspector health ───────────────────────────────────────────
+
+    def check_introspector_health
+      config = RailsAiContext.configuration
+      errors = []
+
+      config.introspectors.each do |name|
+        begin
+          result = RailsAiContext::Introspector.new(app).send(:resolve_introspector, name).call
+          errors << name.to_s if result.is_a?(Hash) && result[:error]
+        rescue => e
+          errors << "#{name} (#{e.message.truncate(50)})"
+        end
+      end
+
+      if errors.empty?
+        Check.new(name: "Introspector health", status: :pass,
+          message: "All #{config.introspectors.size} introspectors return data",
+          fix: nil)
+      else
+        Check.new(name: "Introspector health", status: :warn,
+          message: "#{errors.size} introspector(s) returned errors: #{errors.join(', ')}",
+          fix: "Check if the app has the required features (e.g., stimulus needs app/javascript/controllers/)")
+      end
+    rescue
+      nil
     end
 
+    def check_preset_coverage
+      config = RailsAiContext.configuration
+      suggestions = []
+
+      stimulus_dir = File.join(app.root, "app/javascript/controllers")
+      if Dir.exist?(stimulus_dir) && Dir.glob(File.join(stimulus_dir, "**/*_controller.{js,ts}")).any? && !config.introspectors.include?(:stimulus)
+        suggestions << "stimulus (#{Dir.glob(File.join(stimulus_dir, '**/*_controller.{js,ts}')).size} controllers found)"
+      end
+
+      views_dir = File.join(app.root, "app/views")
+      if Dir.exist?(views_dir) && !config.introspectors.include?(:views)
+        suggestions << "views (app/views/ exists)"
+      end
+
+      i18n_dir = File.join(app.root, "config/locales")
+      if Dir.exist?(i18n_dir) && Dir.glob(File.join(i18n_dir, "**/*.{yml,yaml}")).size > 1 && !config.introspectors.include?(:i18n)
+        suggestions << "i18n (#{Dir.glob(File.join(i18n_dir, '**/*.{yml,yaml}')).size} locale files)"
+      end
+
+      graphql_dir = File.join(app.root, "app/graphql")
+      if Dir.exist?(graphql_dir) && !config.introspectors.include?(:api)
+        suggestions << "api (app/graphql/ exists)"
+      end
+
+      if suggestions.empty?
+        Check.new(name: "Preset coverage", status: :pass,
+          message: "#{config.introspectors.size} introspectors cover detected features",
+          fix: nil)
+      else
+        Check.new(name: "Preset coverage", status: :warn,
+          message: "App has features not in preset: #{suggestions.join(', ')}",
+          fix: "Add with `config.introspectors += %i[#{suggestions.map { |s| s.split(' ').first }.join(' ')}]` or use `config.preset = :full`")
+      end
+    end
+
+    # ── Tool dependencies ─────────────────────────────────────────────
+
     def check_ripgrep
-      if system("which rg > /dev/null 2>&1")
-        Check.new(name: "ripgrep", status: :pass, message: "rg available for code search", fix: nil)
+      if system("which", "rg", out: File::NULL, err: File::NULL)
+        Check.new(name: "ripgrep", status: :pass, message: "rg available for fast code search", fix: nil)
       else
-        Check.new(name: "ripgrep", status: :warn, message: "ripgrep not installed (code search will use slower Ruby fallback)", fix: "Install with `brew install ripgrep` or `apt install ripgrep`")
+        Check.new(name: "ripgrep", status: :warn,
+          message: "ripgrep not installed (slower Ruby fallback)",
+          fix: "Install: `brew install ripgrep` or `apt install ripgrep`")
       end
     end
 
     def check_live_reload
       require "listen"
-      Check.new(name: "Live reload", status: :pass, message: "`listen` gem available for live reload", fix: nil)
+      Check.new(name: "Live reload", status: :pass, message: "`listen` gem available", fix: nil)
     rescue LoadError
-      Check.new(name: "Live reload", status: :warn, message: "`listen` gem not installed (MCP live reload unavailable)", fix: "Add to your Gemfile: gem 'listen', group: :development")
+      Check.new(name: "Live reload", status: :warn,
+        message: "`listen` gem not installed (live reload unavailable)",
+        fix: "Add: `gem 'listen', group: :development`")
+    end
+
+    # ── Security checks ───────────────────────────────────────────────
+
+    def check_security_gitignore
+      issues = []
+      gitignore_path = File.join(app.root, ".gitignore")
+      gitignore = File.exist?(gitignore_path) ? File.read(gitignore_path) : ""
+
+      env_path = File.join(app.root, ".env")
+      if File.exist?(env_path) && !gitignore.include?(".env")
+        issues << ".env exists but not in .gitignore"
+      end
+
+      master_key = File.join(app.root, "config/master.key")
+      if File.exist?(master_key) && !gitignore.include?("master.key")
+        issues << "config/master.key not in .gitignore"
+      end
+
+      if issues.empty?
+        Check.new(name: "Secrets in .gitignore", status: :pass, message: "Sensitive files properly gitignored", fix: nil)
+      else
+        Check.new(name: "Secrets in .gitignore", status: :fail,
+          message: issues.join("; "),
+          fix: "Add to .gitignore: `.env`, `config/master.key`")
+      end
+    end
+
+    def check_security_auto_mount
+      config = RailsAiContext.configuration
+      if config.auto_mount && defined?(Rails.env) && Rails.env.production?
+        Check.new(name: "MCP auto_mount", status: :fail,
+          message: "auto_mount is enabled in production — MCP endpoint is publicly accessible",
+          fix: "Set `config.auto_mount = false` or restrict to development: `config.auto_mount = Rails.env.development?`")
+      else
+        Check.new(name: "MCP auto_mount", status: :pass,
+          message: config.auto_mount ? "auto_mount enabled (non-production)" : "auto_mount disabled (safe)",
+          fix: nil)
+      end
+    end
+
+    # ── Performance checks ────────────────────────────────────────────
+
+    def check_performance_schema_size
+      config = RailsAiContext.configuration
+      schema_path = File.join(app.root, "db/schema.rb")
+      structure_path = File.join(app.root, "db/structure.sql")
+
+      path = File.exist?(schema_path) ? schema_path : (File.exist?(structure_path) ? structure_path : nil)
+      return nil unless path
+
+      size = File.size(path)
+      limit = config.max_schema_file_size
+      pct = ((size.to_f / limit) * 100).round
+
+      if pct >= 80
+        Check.new(name: "Schema file size", status: :warn,
+          message: "#{File.basename(path)} is #{(size / 1_000_000.0).round(1)}MB (#{pct}% of #{(limit / 1_000_000.0).round}MB limit)",
+          fix: "Increase `config.max_schema_file_size` in your initializer")
+      else
+        Check.new(name: "Schema file size", status: :pass,
+          message: "#{File.basename(path)} is #{(size / 1024.0).round}KB (within limit)",
+          fix: nil)
+      end
     end
 
+    def check_performance_view_count
+      config = RailsAiContext.configuration
+      views_dir = File.join(app.root, "app/views")
+      return nil unless Dir.exist?(views_dir)
+
+      count = Dir.glob(File.join(views_dir, "**/*.{erb,haml,slim}")).size
+      total_size = Dir.glob(File.join(views_dir, "**/*.{erb,haml,slim}")).sum { |f| File.size(f) rescue 0 }
+      limit = config.max_view_total_size
+      pct = ((total_size.to_f / limit) * 100).round
+
+      if pct >= 80
+        Check.new(name: "View aggregation size", status: :warn,
+          message: "#{count} view files totaling #{(total_size / 1_000_000.0).round(1)}MB (#{pct}% of #{(limit / 1_000_000.0).round}MB limit for UI pattern extraction)",
+          fix: "Increase `config.max_view_total_size` or `config.max_view_file_size`")
+      else
+        Check.new(name: "View aggregation size", status: :pass,
+          message: "#{count} view files (#{(total_size / 1024.0).round}KB total, within limits)",
+          fix: nil)
+      end
+    end
+
+    # ── Scoring ───────────────────────────────────────────────────────
+
     def compute_score(results)
+      return 0 if results.empty?
       total = results.size * 10
       earned = results.sum do |check|
         case check.status

data/lib/rails_ai_context/version.rb

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

data/server.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "0.15.6",
+  "version": "0.15.8",
   "packages": [
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v0.15.6/rails-ai-context-mcp.mcpb",
+      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v0.15.8/rails-ai-context-mcp.mcpb",
       "fileSha256": "dd711a0ad6c4de943ae4da94eaf59a6dc9494b9d57f726e24649ed4e2f156990",
       "transport": {
         "type": "stdio"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 0.15.8
+  version: 0.15.9
 platform: ruby
 authors:
 - crisnahine