rails-ai-context 1.2.1 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d0ee652e69687c50687cd1b13209688aa5eecc24cf892fa807f9a3d03c7f2de
-  data.tar.gz: e689153ebb668ead61eb375c551a4724c73ce9338ae78a48b6acae63b9a63266
+  metadata.gz: d83d1237d476138591f50c4723cb10a4864aed5ed2e84b7059e53bff287af1db
+  data.tar.gz: 3791bba4e68364ea507050f2605096ce8dff2cacf943ddd111753b768c8152cf
 SHA512:
-  metadata.gz: 415542e44483875ce828fb3476d7d76a84d3df8a3ad3b4a8e512b649563e74bbc570244c5669d16fad7af574d2eb60c8e07fc743dc0126cfcdb4d728fd5b55f5
-  data.tar.gz: e8bc26c2edf09e86eee60b70adeee830b4ed9df130a5da5b658f721077d50cb21d496e677fae0dec7059d7416192b9c0ed27727f786ef76a2522aa63be16a025
+  metadata.gz: 4e3ceb93281e5d3674aab290728357ef75d9d0c24a7d3cee05c9380333ba4d5209b13fdad85a7f015185697d09b9c9093fafc10e628d4dbc1bb897280eb5c388
+  data.tar.gz: 4a0240af3fc7a4ecc303c72107b62f5f5df88fafc189be1f3b19096895dccdd7242ce6e640f7d0f6f148aaed45af7e74f4bf717f773aee3b8cd77107f393c6b0

data/CHANGELOG.md

@@ -5,6 +5,35 @@ 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).
 
+## [1.3.1] - 2026-03-23
+
+### Fixed
+
+- **Documentation audit** — updated tool count from 14 to 15 across README, GUIDE, CONTRIBUTING, server.json. Added `rails_get_design_system` documentation section to GUIDE.md. Updated SECURITY.md supported versions. Fixed spec count in CLAUDE.md. Added `rails_get_design_system` to README tool table. Updated `rails_analyze_feature` description to reflect full-stack discovery (services, jobs, views, Stimulus, tests, related models, env deps).
+- **analyze_feature crash on complex models** — added type guards (`is_a?(Hash)`, `is_a?(Array)`) to all data access points preventing `no implicit conversion of Symbol into Integer` errors on models with many associations or complex data.
+
+## [1.3.0] - 2026-03-23
+
+### Added
+
+- **Full-stack `analyze_feature` tool** — now discovers services (AF1), jobs with queue/retry config (AF2), views with partial/Stimulus refs (AF3), Stimulus controllers with targets/values/actions (AF4), test files with counts (AF5), related models via associations (AF6), concern tracing (AF12), callback chains (AF13), channels (AF10), mailers (AF11), and environment variable dependencies (AF9). One call returns the complete feature picture.
+- **Modal pattern extraction** (DS1) — detects overlay (`fixed inset-0 bg-black/50`) and modal card patterns
+- **List item pattern extraction** (DS5) — detects repeating card/item patterns from views
+- **Shared partials with descriptions** (DS7) — scans `app/views/shared/` and infers purpose (flash, navbar, status badge, loading, modal, etc.)
+- **"When to use what" decision guide** (DS8) — explicit rules: primary button for CTAs, danger for destructive, when to use shared partials
+- **Bootstrap component extraction** (DS13-DS15) — detects `btn-primary`, `card`, `modal`, `form-control`, `badge`, `alert`, `nav` patterns from Bootstrap apps
+- **Tailwind `@apply` directive parsing** (DS16) — extracts named component classes from CSS `@apply` rules
+- **DaisyUI/Flowbite/Headless UI detection** (DS17) — reports Tailwind plugin libraries from package.json
+- **Animation/transition inventory** (DS19) — extracts `transition-*`, `duration-*`, `animate-*`, `ease-*` patterns
+- **Smarter JSONB strong params check** (V1) — only skips params matching JSON column names, validates the rest
+- **Route-action fix suggestions** (V2) — suggests "add `def action; end`" when route exists but action is missing
+
+### Fixed
+
+- **`self` filtered from class methods** (B2/MD1) — no longer appears in model class method lists
+- **Rules serializer methods cap raised to 20** (RS1) — uses introspector's pre-filtered methods directly instead of redundant re-filtering
+- **oklch token noise filtered** (DS21) — complex color values (oklch, calc, var) hidden from summary, only shown in `detail:"full"`
+
 ## [1.2.1] - 2026-03-23
 
 ### Fixed

data/CLAUDE.md

@@ -45,7 +45,7 @@ structure to AI assistants via the Model Context Protocol (MCP).
 ## Testing
 
 ```bash
-bundle exec rspec           # Run specs (520 examples)
+bundle exec rspec           # Run specs (522 examples)
 bundle exec rubocop         # Lint
 ```
 

data/CONTRIBUTING.md

@@ -19,7 +19,7 @@ The test suite uses [Combustion](https://github.com/pat/combustion) to boot a mi
 ```
 lib/rails_ai_context/
 ├── introspectors/     # 29 introspectors (schema, models, routes, etc.)
-├── tools/             # 14 MCP tools with detail levels and pagination
+├── tools/             # 15 MCP tools with detail levels and pagination
 ├── serializers/       # Per-assistant formatters (claude, opencode, cursor, windsurf, copilot, JSON)
 ├── server.rb          # MCP server setup (stdio + HTTP)
 ├── live_reload.rb     # MCP live reload (file watcher + cache invalidation)

data/README.md

@@ -62,7 +62,7 @@ Agent: rails_validate(files:["app/models/cook.rb"], level:"rails") → catches c
 |-------|-----------------|---------------|------------|
 | **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** (14 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 |
+| **Live MCP tools** (15 tools) | Real-time queries: drill into any table, model, controller action, or view on demand. Semantic validation. Design system. | On-demand via agent tool calls | ~25-100 lines per call |
 
 **Progressive disclosure:** the agent gets the map for free, reference guides when relevant, and live GPS when building.
 
@@ -72,7 +72,7 @@ Agent: rails_validate(files:["app/models/cook.rb"], level:"rails") → catches c
 
 | Setup | Tokens | What it knows |
 |-------|--------|---------------|
-| **rails-ai-context (full)** | **28,834** | 14 MCP tools + generated docs + split rules |
+| **rails-ai-context (full)** | **28,834** | 15 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 |
@@ -97,9 +97,9 @@ But token savings is the side effect. The real value:
 
 ---
 
-## 14 Live MCP Tools
+## 15 Live MCP Tools
 
-The gem exposes **14 read-only tools** via MCP that AI clients call on-demand:
+The gem exposes **15 read-only tools** via MCP that AI clients call on-demand:
 
 | Tool | What it returns |
 |------|----------------|
@@ -116,7 +116,8 @@ The gem exposes **14 read-only tools** via MCP that AI clients call on-demand:
 | `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. `level:"rails"` adds semantic checks (partials, route helpers, columns, strong params, callbacks, FK indexes, Stimulus) |
-| `rails_analyze_feature` | End-to-end feature analysis — finds matching models, controllers, routes, and views in one call |
+| `rails_analyze_feature` | Full-stack feature analysis — models, controllers, routes, services, jobs, views, Stimulus, tests, related models, env deps |
+| `rails_get_design_system` | App design system — color palette, component patterns with real HTML examples, typography, layout, responsive breakpoints |
 
 ### Smart Detail Levels
 

data/SECURITY.md

@@ -4,10 +4,9 @@
 
 | Version | Supported          |
 |---------|--------------------|
+| 1.3.x   | :white_check_mark: |
 | 1.2.x   | :white_check_mark: |
-| 1.1.x    | :white_check_mark: |
-| 1.0.x   | :white_check_mark: |
-| < 1.0   | :x:                |
+| < 1.2   | :x:                |
 
 ## Reporting a Vulnerability
 

data/docs/GUIDE.md

@@ -252,7 +252,7 @@ rails ai:context:claude           # Use this instead (no quoting needed)
 
 ## MCP Tools — Full Reference
 
-All 14 tools are **read-only** and **idempotent** — they never modify your application or database.
+All 15 tools are **read-only** and **idempotent** — they never modify your application or database.
 
 ### rails_get_schema
 
@@ -590,7 +590,7 @@ rails_search_code(pattern: "validates", context_lines: 2)
 
 ### rails_analyze_feature
 
-Analyzes a feature end-to-end: finds matching models, controllers, routes, and views in one call.
+Full-stack feature analysis: models, controllers, routes, services, jobs, views, Stimulus controllers, tests, related models, concerns, callbacks, channels, mailers, and environment dependencies in one call.
 
 **Parameters:**
 
@@ -616,7 +616,34 @@ rails_analyze_feature(feature: "orders")
   → Everything related to orders across all layers
 ```
 
-**Returns:** Markdown with sections for Models (with table, columns, indexes, FKs, associations, validations, scopes), Controllers (with actions and filters), and Routes (with verbs, paths, and route names). Each section shows match counts.
+**Returns:** Markdown with sections for Models (with columns, associations, validations, scopes, enums), Controllers (with actions and filters), Routes, Services (with methods), Jobs (with queue/retry), Views (with partials and Stimulus refs), Stimulus controllers (with targets/values/actions), Tests (with counts), Related models, Concerns, Callbacks, Channels, Mailers, and Environment dependencies. Each section shows match counts.
+
+### rails_get_design_system
+
+Returns the app's design system: color palette with semantic roles, component patterns with real HTML examples from actual views, typography scale, layout conventions, responsive breakpoints, and interactive state patterns.
+
+**Parameters:**
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `detail` | string | `summary` (palette + components), `standard` (+ canonical page examples + design rules, default), `full` (+ typography, responsive, dark mode, animations, design tokens) |
+
+**Examples:**
+
+```
+rails_get_design_system()
+  → Color palette (primary, danger, success), component patterns (buttons, cards, inputs),
+    canonical page examples (form page, list page), design rules
+
+rails_get_design_system(detail: "summary")
+  → Compact: color roles + component class strings only
+
+rails_get_design_system(detail: "full")
+  → Everything: + typography scale, responsive breakpoints, interactive states,
+    dark mode patterns, animations, icon system, design tokens, shared partials
+```
+
+**Returns:** Structured design system reference. Includes real HTML/ERB snippets from the app's actual views as canonical examples, semantic color roles (primary for CTAs, danger for destructive), component variants, typography hierarchy, spacing scale, and explicit design rules for AI to follow.
 
 ### Detail Level Summary
 
@@ -746,7 +773,7 @@ RailsAiContext.configure do |config|
 end
 ```
 
-Both transports are **read-only** — they expose the same 14 tools and never modify your app.
+Both transports are **read-only** — they expose the same 15 tools and never modify your app.
 
 ---
 

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -171,6 +171,10 @@ module RailsAiContext
                 f[:if] = sc[:if] if sc[:if]
               end
             end
+
+            # Evaluate known runtime conditions to remove inapplicable filters
+            reflection_filters.reject! { |f| filter_excluded_by_condition?(ctrl, f) }
+
             return reflection_filters
           end
         end
@@ -258,6 +262,29 @@ module RailsAiContext
         nil
       end
 
+      # Statically evaluate known runtime conditions to exclude inapplicable filters.
+      # e.g., `unless: :devise_controller?` on a Devise controller means the filter doesn't apply.
+      def filter_excluded_by_condition?(ctrl, filter)
+        # unless: :devise_controller? — filter does NOT apply to Devise controllers
+        if filter[:unless] == "devise_controller?"
+          return true if devise_controller?(ctrl)
+        end
+
+        # if: :devise_controller? — filter ONLY applies to Devise controllers
+        if filter[:if] == "devise_controller?"
+          return true unless devise_controller?(ctrl)
+        end
+
+        false
+      end
+
+      def devise_controller?(ctrl)
+        return false unless defined?(::DeviseController)
+        ctrl < ::DeviseController || ctrl.ancestors.any? { |a| a.name&.start_with?("Devise::") }
+      rescue
+        false
+      end
+
       def extract_action_condition(condition)
         return nil unless condition.is_a?(String) || condition.respond_to?(:to_s)
         match = condition.to_s.match(/action_name\s*==\s*['"](\w+)['"]/)

data/lib/rails_ai_context/introspectors/design_token_introspector.rb

@@ -32,6 +32,7 @@ module RailsAiContext
         extract_css_custom_properties(root, tokens)
         extract_webpacker_styles(root, tokens)
         extract_component_css(root, tokens)
+        extract_apply_directives(root, tokens)
 
         return { skipped: true, reason: "No design tokens found" } if tokens.empty?
 
@@ -48,20 +49,29 @@ module RailsAiContext
 
       def detect_framework(root)
         gemfile = File.join(root, "Gemfile")
-        return "unknown" unless File.exist?(gemfile)
-        content = File.read(gemfile, encoding: "UTF-8", invalid: :replace, undef: :replace)
+        package_json = File.join(root, "package.json")
+        gemfile_content = File.exist?(gemfile) ? (File.read(gemfile, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue "") : ""
+        pkg_content = File.exist?(package_json) ? (File.read(package_json, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue "") : ""
 
-        if content.include?("tailwindcss-rails")
+        framework = if gemfile_content.include?("tailwindcss-rails")
           "tailwind"
-        elsif content.include?("bootstrap")
+        elsif gemfile_content.include?("bootstrap")
           "bootstrap"
-        elsif content.include?("dartsass-rails") || content.include?("sassc-rails") || content.include?("sass-rails")
+        elsif gemfile_content.include?("dartsass-rails") || gemfile_content.include?("sassc-rails") || gemfile_content.include?("sass-rails")
           "sass"
-        elsif content.include?("cssbundling-rails")
+        elsif gemfile_content.include?("cssbundling-rails")
           "cssbundling"
         else
           "plain_css"
         end
+
+        # DS17: Detect Tailwind plugin libraries
+        plugins = []
+        plugins << "daisyui" if pkg_content.include?("daisyui") || gemfile_content.include?("daisyui")
+        plugins << "flowbite" if pkg_content.include?("flowbite")
+        plugins << "headlessui" if pkg_content.include?("headlessui") || pkg_content.include?("@headlessui")
+
+        plugins.any? ? "#{framework}+#{plugins.join('+')}" : framework
       rescue
         "unknown"
       end
@@ -238,6 +248,18 @@ module RailsAiContext
         categories.reject { |_, v| v.empty? }
       end
 
+      # DS16: Extract @apply directives as named component classes
+      def extract_apply_directives(root, tokens)
+        %w[app/assets/stylesheets app/assets/tailwind].each do |dir|
+          Dir.glob(File.join(root, dir, "**", "*.css")).each do |path|
+            content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            content.scan(/\.([a-zA-Z][\w-]*)\s*\{[^}]*@apply\s+([^;]+);/m).each do |name, classes|
+              tokens["@apply-#{name}"] = classes.strip
+            end
+          end
+        end
+      end
+
       # Helper: extract :root { --var: value } from CSS content
       def extract_root_vars(content, tokens)
         content.scan(/:root\s*(?:,\s*:host)?\s*\{([^}]+)\}/m).each do |match|

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -239,7 +239,8 @@ module RailsAiContext
         all_methods = (model.methods - ActiveRecord::Base.methods - Object.methods)
           .reject { |m|
             ms = m.to_s
-            ms.start_with?("_", "autosave") ||
+            ms == "self" ||
+              ms.start_with?("_", "autosave") ||
               scope_names.include?(ms) ||
               DEVISE_CLASS_METHOD_PATTERNS.include?(ms) ||
               ms.end_with?("=") && ms.length > 20 # Devise setter-like methods

data/lib/rails_ai_context/introspectors/view_template_introspector.rb

@@ -21,7 +21,8 @@ module RailsAiContext
           templates: scan_templates(views_dir),
           partials: scan_partials(views_dir),
           ui_patterns: extract_ui_patterns(all_content).merge(
-            canonical_examples: extract_canonical_examples(views_dir)
+            canonical_examples: extract_canonical_examples(views_dir),
+            shared_partials: discover_shared_partials(views_dir)
           )
         }
       rescue => e
@@ -86,7 +87,10 @@ module RailsAiContext
         components = []
         used = Set.new
 
-        # Extract element-aware patterns
+        # DS13-15: Framework-aware component extraction
+        extract_bootstrap_components(all_content, components, used) if all_content.match?(/btn-|form-control|card-body/)
+
+        # Extract element-aware patterns (Tailwind + generic)
         extract_buttons(all_content, class_groups, components, used)
         extract_cards(class_groups, components, used)
         extract_inputs(all_content, class_groups, components, used)
@@ -98,6 +102,8 @@ module RailsAiContext
         extract_headings(all_content, components)
         extract_flashes(all_content, components)
         extract_alerts(class_groups, components, used)
+        extract_modals(all_content, class_groups, components, used)
+        extract_list_items(class_groups, components, used)
 
         # Design tokens
         color_scheme = extract_color_scheme(all_content, class_groups)
@@ -114,7 +120,8 @@ module RailsAiContext
           responsive: extract_responsive_patterns(all_content),
           interactive_states: extract_interactive_states(all_content),
           dark_mode: extract_dark_mode_patterns(all_content),
-          icons: extract_icon_system(all_content)
+          icons: extract_icon_system(all_content),
+          animations: extract_animations(all_content)
         }
       end
 
@@ -302,6 +309,71 @@ module RailsAiContext
         components << { type: :alert, label: "Alert", classes: best[0] }
       end
 
+      # DS13-15: Bootstrap component extraction
+      def extract_bootstrap_components(content, components, used)
+        bootstrap_patterns = {
+          "btn-primary" => { type: :button, label: "Button (primary)" },
+          "btn-secondary" => { type: :button, label: "Button (secondary)" },
+          "btn-danger" => { type: :button, label: "Button (danger)" },
+          "btn-outline-primary" => { type: :button, label: "Button (outline)" },
+          "card" => { type: :card, label: "Card" },
+          "modal" => { type: :modal_card, label: "Modal" },
+          "form-control" => { type: :input, label: "Input" },
+          "form-select" => { type: :select, label: "Select" },
+          "badge" => { type: :badge, label: "Badge" },
+          "alert" => { type: :alert, label: "Alert" },
+          "nav" => { type: :nav, label: "Navigation" }
+        }
+
+        bootstrap_patterns.each do |pattern, meta|
+          matches = content.scan(/class=["'][^"']*\b#{pattern}\b[^"']*["']/).map do |m|
+            m.gsub(/class=["']|["']/, "").strip
+          end
+          next if matches.empty?
+
+          best = matches.tally.max_by { |_, c| c }
+          unless used.include?(best[0])
+            components << meta.merge(classes: best[0])
+            used << best[0]
+          end
+        end
+      end
+
+      # DS1: Modal/overlay patterns
+      def extract_modals(content, groups, components, used)
+        # Detect overlay pattern (fixed inset-0 bg-black/50 or similar)
+        overlay = groups.select { |c, _| c.match?(/fixed.*inset-0|fixed.*z-\d+.*bg-/) && !used.include?(c) }
+        if overlay.any?
+          best = overlay.max_by { |_, count| count }
+          components << { type: :modal_overlay, label: "Modal overlay", classes: best[0] }
+          used << best[0]
+        end
+
+        # Detect modal card (usually the child of overlay)
+        modal_card = groups.select do |c, _|
+          c.match?(/bg-white.*rounded.*shadow.*max-w-|modal/) && c.match?(/p-\d/) && !used.include?(c)
+        end
+        if modal_card.any?
+          best = modal_card.max_by { |_, count| count }
+          components << { type: :modal_card, label: "Modal card", classes: best[0] }
+          used << best[0]
+        end
+      end
+
+      # DS5: List item / repeating card pattern
+      def extract_list_items(groups, components, used)
+        candidates = groups.select do |c, count|
+          count >= 3 && # appears 3+ times (repeating pattern)
+            c.match?(/(?:flex|grid).*(?:items-|justify-|gap-)/) &&
+            c.match?(/(?:bg-white|border|shadow|rounded)/) &&
+            !used.include?(c)
+        end
+        return if candidates.empty?
+        best = candidates.max_by { |_, count| count }
+        components << { type: :list_item, label: "List item", classes: best[0] }
+        used << best[0]
+      end
+
       def extract_color_scheme(content, groups)
         # Find primary color from button backgrounds
         primary_colors = Hash.new(0)
@@ -452,6 +524,29 @@ module RailsAiContext
         icons.empty? ? nil : icons
       end
 
+      # DS19: Animation and transition patterns
+      def extract_animations(content)
+        animations = {}
+
+        # Transition classes
+        transitions = content.scan(/transition(?:-\w+)*/).tally
+        animations[:transitions] = transitions.sort_by { |_, c| -c }.first(5).to_h unless transitions.empty?
+
+        # Duration classes
+        durations = content.scan(/duration-\d+/).tally
+        animations[:durations] = durations.sort_by { |_, c| -c }.first(3).to_h unless durations.empty?
+
+        # Animate classes
+        animates = content.scan(/animate-\w+/).tally
+        animations[:animates] = animates.sort_by { |_, c| -c }.first(5).to_h unless animates.empty?
+
+        # Ease classes
+        eases = content.scan(/ease-\w+/).tally
+        animations[:easing] = eases.sort_by { |_, c| -c }.first(3).to_h unless eases.empty?
+
+        animations.empty? ? nil : animations
+      end
+
       # Analyzes individual templates to find canonical examples of common page types.
       # Returns up to 5 representative ERB snippets that AI can copy.
       def extract_canonical_examples(views_dir) # rubocop:disable Metrics
@@ -541,6 +636,36 @@ module RailsAiContext
         used
       end
 
+      # DS7: Shared partials with one-line descriptions
+      def discover_shared_partials(views_dir)
+        shared_dir = File.join(views_dir, "shared")
+        return [] unless Dir.exist?(shared_dir)
+
+        Dir.glob(File.join(shared_dir, "_*.{erb,haml,slim}")).sort.map do |path|
+          name = File.basename(path)
+          content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue ""
+          description = infer_partial_description(name, content)
+          { name: name, lines: content.lines.size, description: description }
+        end
+      rescue
+        []
+      end
+
+      def infer_partial_description(name, content)
+        # Infer from content patterns
+        return "Flash/notification messages" if name.include?("flash") || name.include?("notification")
+        return "Navigation bar" if name.include?("nav") || name.include?("header")
+        return "Footer" if name.include?("footer")
+        return "Status badge/indicator" if name.include?("status") || name.include?("badge")
+        return "Loading/spinner" if name.include?("loading") || name.include?("spinner") || content.include?("animate-spin")
+        return "Modal dialog" if name.include?("modal") || name.include?("dialog")
+        return "Form component" if name.include?("form") || content.match?(/form_with|form_for/)
+        return "Upgrade prompt" if name.include?("upgrade") || name.include?("nudge")
+        return "Share dialog" if name.include?("share")
+        return "Error display" if name.include?("error")
+        "Shared partial (#{content.lines.size} lines)"
+      end
+
       EXCLUDED_METHODS = %w[
         each map select reject first last size count any? empty? present? blank?
         new build create find where order limit nil? join class html_safe

data/lib/rails_ai_context/serializers/claude_rules_serializer.rb

@@ -218,30 +218,8 @@ module RailsAiContext
           scopes = data[:scopes] || []
           lines << "  scopes: #{scopes.join(', ')}" if scopes.any?
 
-          # Include app-specific instance methods (filter out Rails/Devise-generated ones)
-          generated_patterns = %w[build_ create_ reload_ reset_ _changed? _previously_changed?
-                                  _ids _ids= _before_last_save _before_type_cast _came_from_user?
-                                  _for_database _in_database _was]
-          # Filter out association getters (cooks, user, plan, etc.)
-          assoc_names = (data[:associations] || []).flat_map { |a| [ a[:name].to_s, "#{a[:name]}=" ] }
-          # Filter out Devise and other framework-generated methods
-          devise_methods = %w[active_for_authentication? after_database_authentication after_remembered
-                              authenticatable_salt inactive_message confirmation_required?
-                              send_confirmation_instructions password_required? email_required?
-                              will_save_change_to_email? clean_up_passwords current_password
-                              destroy_with_password devise_mailer devise_modules devise_scope
-                              send_devise_notification valid_password? update_with_password
-                              send_reset_password_instructions apply_to_attribute_or_variable
-                              allowed_gemini_models remember_me! forget_me!
-                              skip_confirmation! skip_reconfirmation!]
-          devise_patterns = %w[devise_ _password _authenticatable _confirmation _recoverable]
-          methods = (data[:instance_methods] || []).reject { |m|
-            generated_patterns.any? { |p| m.include?(p) } ||
-              m.end_with?("=") ||
-              assoc_names.include?(m) ||
-              devise_methods.include?(m) ||
-              devise_patterns.any? { |p| m.include?(p) }
-          }.first(10)
+          # Instance methods — introspector already prioritizes source-defined and filters Devise
+          methods = (data[:instance_methods] || []).reject { |m| m.end_with?("=") }.first(20)
           lines << "  methods: #{methods.join(', ')}" if methods.any?
 
           # Include constants (e.g. STATUSES, MODES) so agents know valid values

data/lib/rails_ai_context/serializers/design_system_helper.rb

@@ -32,6 +32,7 @@ module RailsAiContext
         lines.concat(render_spacing_summary(patterns))
         lines.concat(render_interaction_summary(patterns))
         lines.concat(render_dark_mode_summary(patterns))
+        lines.concat(render_decision_guide(patterns))
         lines.concat(render_design_rules(patterns))
 
         lines.first(max_lines)
@@ -83,6 +84,17 @@ module RailsAiContext
           lines << ""
         end
 
+        # Shared partials with descriptions
+        shared = patterns[:shared_partials] || []
+        if shared.any?
+          lines << "## Shared Partials — Reuse Before Creating New Markup"
+          lines << ""
+          shared.each do |p|
+            lines << "- `#{p[:name]}` — #{p[:description]}"
+          end
+          lines << ""
+        end
+
         lines
       end
 
@@ -201,6 +213,41 @@ module RailsAiContext
         lines
       end
 
+      # DS8: Decision guide — when to use what
+      def render_decision_guide(patterns)
+        components = patterns[:components] || []
+        return [] if components.size < 3
+
+        lines = [ "### When to Use What" ]
+
+        # Button decisions
+        has_primary = components.any? { |c| c[:label]&.include?("primary") }
+        has_danger = components.any? { |c| c[:label]&.include?("danger") }
+        has_secondary = components.any? { |c| c[:label]&.include?("secondary") }
+        if has_primary || has_danger
+          lines << "- **Primary action** (Save, Submit, Continue) → Primary button"
+          lines << "- **Secondary action** (Cancel, Back, Skip) → Secondary button" if has_secondary
+          lines << "- **Destructive action** (Delete, Remove) → Danger button" if has_danger
+        end
+
+        # Turbo confirm
+        lines << "- **Confirmation needed** → `data: { turbo_confirm: \"Are you sure?\" }` on `button_to`"
+
+        # Shared partials usage
+        shared = patterns[:shared_partials] || []
+        shared.each do |p|
+          case p[:name]
+          when /flash|notification/ then lines << "- **Show feedback** → `render \"shared/#{p[:name].sub(/\A_/, '').sub(/\..*/, '')}\"` "
+          when /status|badge/ then lines << "- **Show status** → `render \"shared/#{p[:name].sub(/\A_/, '').sub(/\..*/, '')}\"` "
+          when /modal|dialog/ then lines << "- **Need overlay/dialog** → `render \"shared/#{p[:name].sub(/\A_/, '').sub(/\..*/, '')}\"` "
+          when /loading|spinner/ then lines << "- **Show loading** → `render \"shared/#{p[:name].sub(/\A_/, '').sub(/\..*/, '')}\"` "
+          end
+        end
+
+        lines << ""
+        lines
+      end
+
       def render_design_rules(patterns)
         lines = [ "### Design Rules" ]
 

data/lib/rails_ai_context/tools/analyze_feature.rb

@@ -4,7 +4,8 @@ module RailsAiContext
   module Tools
     class AnalyzeFeature < BaseTool
       tool_name "rails_analyze_feature"
-      description "Analyze a feature end-to-end: finds matching models, controllers, routes, and views in one call. " \
+      description "Full-stack feature analysis: models, controllers, routes, services, jobs, views, " \
+        "Stimulus controllers, tests, related models, callbacks, concerns, and environment dependencies. " \
         "Use when: exploring an unfamiliar feature, onboarding to a codebase area, or tracing a feature across layers. " \
         "Pass feature:\"authentication\" or feature:\"User\" for broad cross-cutting discovery."
 
@@ -12,7 +13,7 @@ module RailsAiContext
         properties: {
           feature: {
             type: "string",
-            description: "Feature keyword to search for (e.g. 'authentication', 'User', 'payments', 'orders'). Case-insensitive partial match across models, controllers, and routes."
+            description: "Feature keyword to search for (e.g. 'authentication', 'User', 'payments', 'orders'). Case-insensitive partial match across all layers."
           }
         },
         required: [ "feature" ]
@@ -20,95 +21,385 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
-      def self.call(feature:, server_context: nil)
+      def self.call(feature:, server_context: nil) # rubocop:disable Metrics
         ctx = cached_context
         pattern = feature.downcase
+        root = rails_app.root.to_s
         lines = [ "# Feature Analysis: #{feature}", "" ]
 
-        # --- Models ---
-        models = ctx[:models] || {}
-        matched_models = models.select do |name, data|
-          next false if data[:error]
-          # Match on model name, table name, or underscore form
-          name.downcase.include?(pattern) ||
-            data[:table_name]&.downcase&.include?(pattern) ||
-            name.underscore.include?(pattern)
-        end
+        matched_models = discover_models(ctx, pattern, lines)
+        discover_controllers(ctx, pattern, lines)
+        discover_routes(ctx, pattern, lines)
+        discover_services(root, pattern, lines)
+        discover_jobs(root, pattern, lines)
+        discover_views(ctx, root, pattern, lines)
+        discover_stimulus(ctx, pattern, lines)
+        discover_tests(root, pattern, lines)
+        discover_related_models(ctx, matched_models, lines)
+        discover_concerns(ctx, matched_models, lines)
+        discover_callbacks(ctx, matched_models, lines)
+        discover_channels(root, pattern, lines)
+        discover_mailers(root, pattern, lines)
+        discover_env_dependencies(root, pattern, matched_models, lines)
 
-        if matched_models.any?
-          lines << "## Models (#{matched_models.size} matched)"
-          matched_models.sort.each do |name, data|
-            lines << ""
-            lines << "### #{name}"
-            lines << "**Table:** `#{data[:table_name]}`" if data[:table_name]
-
-            # Schema columns from schema introspection
-            table_name = data[:table_name]
-            if table_name && (schema = ctx[:schema]) && (tables = schema[:tables])
-              table_data = tables[table_name]
-              if table_data && table_data[:columns]&.any?
-                cols = table_data[:columns].reject { |c| %w[id created_at updated_at].include?(c[:name]) }
-                lines << "**Columns:** #{cols.map { |c| "#{c[:name]}:#{c[:type]}" }.join(', ')}" if cols.any?
-                if table_data[:indexes]&.any?
-                  lines << "**Indexes:** #{table_data[:indexes].map { |i| "#{i[:columns].join(',')}#{i[:unique] ? ' (unique)' : ''}" }.join('; ')}"
-                end
-                if table_data[:foreign_keys]&.any?
-                  lines << "**FKs:** #{table_data[:foreign_keys].map { |fk| "#{fk[:column]} -> #{fk[:to_table]}" }.join(', ')}"
+        text_response(lines.join("\n"))
+      end
+
+      class << self
+        private
+
+        # --- AF: Models ---
+        def discover_models(ctx, pattern, lines)
+          models = ctx[:models] || {}
+          matched = models.select do |name, data|
+            next false if data[:error]
+            name.downcase.include?(pattern) ||
+              data[:table_name]&.downcase&.include?(pattern) ||
+              name.underscore.include?(pattern)
+          end
+
+          if matched.any?
+            lines << "## Models (#{matched.size})"
+            matched.sort.each do |name, data|
+              lines << "" << "### #{name}"
+              lines << "**Table:** `#{data[:table_name]}`" if data[:table_name]
+
+              table_name = data[:table_name]
+              if table_name && (tables = ctx.dig(:schema, :tables))
+                table_data = tables[table_name]
+                if table_data&.dig(:columns)&.any?
+                  cols = table_data[:columns].reject { |c| %w[id created_at updated_at].include?(c[:name]) }
+                  col_strs = cols.map { |c| col_type = c[:array] ? "#{c[:type]}[]" : c[:type]; "#{c[:name]}:#{col_type}" }
+                  lines << "**Columns:** #{col_strs.join(', ')}" if cols.any?
                 end
               end
-            end
 
-            if data[:associations]&.any?
-              lines << "**Associations:** #{data[:associations].map { |a| "#{a[:type]} :#{a[:name]}" }.join(', ')}"
+              if data[:associations].is_a?(Array) && data[:associations].any?
+                lines << "**Associations:** #{data[:associations].select { |a| a.is_a?(Hash) }.map { |a| "#{a[:type]} :#{a[:name]}" }.join(', ')}"
+              end
+              if data[:validations].is_a?(Array) && data[:validations].any?
+                lines << "**Validations:** #{data[:validations].select { |v| v.is_a?(Hash) }.map { |v| "#{v[:kind]} on #{Array(v[:attributes]).join(', ')}" }.uniq.join('; ')}"
+              end
+              lines << "**Scopes:** #{data[:scopes].join(', ')}" if data[:scopes].is_a?(Array) && data[:scopes].any?
+              if data[:enums].is_a?(Hash) && data[:enums].any?
+                lines << "**Enums:** #{data[:enums].map { |k, v| "#{k}: #{Array(v).join(', ')}" }.join('; ')}"
+              end
             end
-            if data[:validations]&.any?
-              lines << "**Validations:** #{data[:validations].map { |v| "#{v[:kind]} on #{v[:attributes].join(', ')}" }.uniq.join('; ')}"
+          else
+            lines << "## Models" << "_No models matching '#{pattern}'._"
+          end
+
+          lines << ""
+          matched
+        end
+
+        # --- AF: Controllers ---
+        def discover_controllers(ctx, pattern, lines)
+          controllers = ctx.dig(:controllers, :controllers) || {}
+          matched = controllers.select { |name, data| data.is_a?(Hash) && !data[:error] && name.downcase.include?(pattern) }
+
+          if matched.any?
+            lines << "## Controllers (#{matched.size})"
+            matched.sort.each do |name, info|
+              actions = info[:actions]&.join(", ") || "none"
+              lines << "" << "### #{name}"
+              lines << "- **Actions:** #{actions}"
+              filters = (info[:filters] || []).select { |f| f.is_a?(Hash) }.map do |f|
+                label = "#{f[:kind]} #{f[:name]}"
+                label += " only: #{Array(f[:only]).join(', ')}" if f[:only]&.any?
+                label += " except: #{Array(f[:except]).join(', ')}" if f[:except]&.any?
+                label += " unless: #{f[:unless]}" if f[:unless]
+                label
+              end
+              lines << "- **Filters:** #{filters.join('; ')}" if filters.any?
             end
-            if data[:scopes]&.any?
-              lines << "**Scopes:** #{data[:scopes].join(', ')}"
+          else
+            lines << "## Controllers" << "_No controllers matching '#{pattern}'._"
+          end
+          lines << ""
+        end
+
+        # --- AF: Routes ---
+        def discover_routes(ctx, pattern, lines)
+          by_controller = ctx.dig(:routes, :by_controller) || {}
+          matched = by_controller.select { |ctrl, _| ctrl.downcase.include?(pattern) }
+
+          if matched.any?
+            route_count = matched.values.sum(&:size)
+            lines << "## Routes (#{route_count})"
+            matched.sort.each do |ctrl, actions|
+              actions.each do |r|
+                name_part = r[:name] ? " `#{r[:name]}`" : ""
+                lines << "- `#{r[:verb]}` `#{r[:path]}` → #{ctrl}##{r[:action]}#{name_part}"
+              end
             end
+          else
+            lines << "## Routes" << "_No routes matching '#{pattern}'._"
           end
-        else
-          lines << "## Models" << "_No models matching '#{feature}'._"
+          lines << ""
         end
 
-        # --- Controllers ---
-        controllers = (ctx.dig(:controllers, :controllers) || {})
-        matched_controllers = controllers.select { |name, data| !data[:error] && name.downcase.include?(pattern) }
+        # --- AF1: Services ---
+        def discover_services(root, pattern, lines)
+          dir = File.join(root, "app", "services")
+          return unless Dir.exist?(dir)
+
+          found = Dir.glob(File.join(dir, "**", "*.rb")).select do |path|
+            File.basename(path, ".rb").include?(pattern) ||
+              (File.size(path) < 50_000 && File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace).downcase.include?(pattern))
+          end
+          return if found.empty?
 
-        lines << ""
-        if matched_controllers.any?
-          lines << "## Controllers (#{matched_controllers.size} matched)"
-          matched_controllers.sort.each do |name, info|
-            actions = info[:actions]&.join(", ") || "none"
-            filters = (info[:filters] || []).map { |f| "#{f[:kind]} #{f[:name]}" }.join(", ")
+          lines << "## Services (#{found.size})"
+          found.each do |path|
+            relative = path.sub("#{root}/", "")
+            source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            line_count = source.lines.size
+            methods = source.scan(/\A\s*def (?:self\.)?(\w+)/m).flatten.reject { |m| m == "initialize" }
+            lines << "- `#{relative}` (#{line_count} lines)"
+            lines << "  Methods: #{methods.first(10).join(', ')}" if methods.any?
+          end
+          lines << ""
+        rescue
+          nil
+        end
+
+        # --- AF2: Jobs ---
+        def discover_jobs(root, pattern, lines)
+          dir = File.join(root, "app", "jobs")
+          return unless Dir.exist?(dir)
+
+          found = Dir.glob(File.join(dir, "**", "*.rb")).select do |path|
+            File.basename(path, ".rb").include?(pattern)
+          end
+          return if found.empty?
+
+          lines << "## Jobs (#{found.size})"
+          found.each do |path|
+            relative = path.sub("#{root}/", "")
+            source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            queue = source.match(/queue_as\s+[:'"](\w+)/)&.captures&.first || "default"
+            retries = source.match(/retry_on.*attempts:\s*(\d+)/)&.captures&.first
+            lines << "- `#{relative}` (queue: #{queue}#{retries ? ", retries: #{retries}" : ""})"
+          end
+          lines << ""
+        rescue
+          nil
+        end
+
+        # --- AF3: Views + Partials ---
+        def discover_views(ctx, root, pattern, lines)
+          views_dir = File.join(root, "app", "views")
+          return unless Dir.exist?(views_dir)
+
+          found = Dir.glob(File.join(views_dir, "**", "*.{erb,haml,slim}")).select do |path|
+            path.sub("#{views_dir}/", "").downcase.include?(pattern)
+          end
+          return if found.empty?
+
+          lines << "## Views (#{found.size})"
+          found.each do |path|
+            relative = path.sub("#{views_dir}/", "")
+            source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            line_count = source.lines.size
+            partials = source.scan(/render\s+(?:partial:\s*)?["']([^"']+)["']/).flatten
+            stimulus = source.scan(/data-controller=["']([^"']+)["']/).flat_map { |m| m.first.split }
+            detail = "- `#{relative}` (#{line_count} lines)"
+            detail += " renders: #{partials.join(', ')}" if partials.any?
+            detail += " stimulus: #{stimulus.join(', ')}" if stimulus.any?
+            lines << detail
+          end
+          lines << ""
+        rescue
+          nil
+        end
+
+        # --- AF4: Stimulus Controllers ---
+        def discover_stimulus(ctx, pattern, lines)
+          stim = ctx[:stimulus]
+          return unless stim.is_a?(Hash) && !stim[:error]
+
+          controllers = stim[:controllers] || []
+          matched = controllers.select do |c|
+            name = c[:name] || c[:file]&.gsub("_controller.js", "")
+            name&.downcase&.include?(pattern)
+          end
+          return if matched.empty?
+
+          lines << "## Stimulus Controllers (#{matched.size})"
+          matched.each do |c|
+            name = c[:name] || c[:file]&.gsub("_controller.js", "")
             lines << "" << "### #{name}"
-            lines << "- **Actions:** #{actions}"
-            lines << "- **Filters:** #{filters}" unless filters.empty?
+            lines << "- **Targets:** #{Array(c[:targets]).join(', ')}" if c[:targets]&.any?
+            if c[:values]&.any?
+              val_strs = if c[:values].is_a?(Array)
+                c[:values].select { |v| v.is_a?(Hash) }.map { |v| "#{v[:name]}:#{v[:type]}" }
+              elsif c[:values].is_a?(Hash)
+                c[:values].map { |k, v| "#{k}:#{v}" }
+              else
+                []
+              end
+              lines << "- **Values:** #{val_strs.join(', ')}" if val_strs.any?
+            end
+            lines << "- **Actions:** #{Array(c[:actions]).join(', ')}" if c[:actions]&.any?
           end
-        else
-          lines << "## Controllers" << "_No controllers matching '#{feature}'._"
+          lines << ""
         end
 
-        # --- Routes ---
-        by_controller = (ctx.dig(:routes, :by_controller) || {})
-        matched_routes = by_controller.select { |ctrl, _| ctrl.downcase.include?(pattern) }
-
-        lines << ""
-        if matched_routes.any?
-          route_count = matched_routes.values.sum(&:size)
-          lines << "## Routes (#{route_count} matched)"
-          matched_routes.sort.each do |ctrl, actions|
-            actions.each do |r|
-              name_part = r[:name] ? " `#{r[:name]}`" : ""
-              lines << "- `#{r[:verb]}` `#{r[:path]}` -> #{ctrl}##{r[:action]}#{name_part}"
+        # --- AF5: Tests ---
+        def discover_tests(root, pattern, lines)
+          test_dirs = [ File.join(root, "spec"), File.join(root, "test") ]
+          found = []
+
+          test_dirs.each do |dir|
+            next unless Dir.exist?(dir)
+            Dir.glob(File.join(dir, "**", "*_{test,spec}.rb")).each do |path|
+              found << path if File.basename(path, ".rb").include?(pattern)
+            end
+            Dir.glob(File.join(dir, "**", "{test,spec}_*.rb")).each do |path|
+              found << path if File.basename(path, ".rb").include?(pattern)
             end
           end
-        else
-          lines << "## Routes" << "_No routes matching '#{feature}'._"
+          found.uniq!
+          return if found.empty?
+
+          lines << "## Tests (#{found.size})"
+          found.each do |path|
+            relative = path.sub("#{root}/", "")
+            source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            test_count = source.scan(/\b(?:it|test|should)\b/).size
+            lines << "- `#{relative}` (#{test_count} tests)"
+          end
+          lines << ""
+        rescue
+          nil
         end
 
-        text_response(lines.join("\n"))
+        # --- AF6: Related Models via Associations ---
+        def discover_related_models(ctx, matched_models, lines)
+          return if matched_models.empty?
+
+          related = {}
+          matched_models.each do |name, data|
+            next unless data.is_a?(Hash)
+            (data[:associations] || []).each do |a|
+              next unless a.is_a?(Hash)
+              related_name = a[:class_name] || a[:name].to_s.classify
+              next if matched_models.key?(related_name)
+              related[related_name] ||= []
+              related[related_name] << "#{a[:type]} from #{name}"
+            end
+          end
+          return if related.empty?
+
+          lines << "## Related Models (#{related.size})"
+          related.sort.each { |name, refs| lines << "- **#{name}** — #{refs.join(', ')}" }
+          lines << ""
+        end
+
+        # --- AF12: Concern Tracing ---
+        def discover_concerns(ctx, matched_models, lines)
+          return if matched_models.empty?
+
+          concerns = {}
+          matched_models.each do |_name, data|
+            next unless data.is_a?(Hash)
+            (data[:concerns] || []).each do |c|
+              next unless c.is_a?(String)
+              next if c.include?("::") || %w[Kernel JSON PP].include?(c)
+              concerns[c] ||= 0
+              concerns[c] += 1
+            end
+          end
+          return if concerns.empty?
+
+          lines << "## Concerns"
+          concerns.sort.each { |name, count| lines << "- **#{name}** (used by #{count} model#{'s' if count > 1})" }
+          lines << ""
+        rescue
+          nil
+        end
+
+        # --- AF13: Callback Chains ---
+        def discover_callbacks(ctx, matched_models, lines)
+          return if matched_models.empty?
+
+          callbacks = []
+          matched_models.each do |name, data|
+            next unless data.is_a?(Hash)
+            (data[:callbacks] || {}).each do |type, methods|
+              next unless methods.is_a?(Array)
+              methods.each { |m| callbacks << "#{name}: #{type} :#{m}" }
+            end
+          end
+          return if callbacks.empty?
+
+          lines << "## Callbacks"
+          callbacks.each { |c| lines << "- #{c}" }
+          lines << ""
+        end
+
+        # --- AF10: Channels/WebSocket ---
+        def discover_channels(root, pattern, lines)
+          dir = File.join(root, "app", "channels")
+          return unless Dir.exist?(dir)
+
+          found = Dir.glob(File.join(dir, "**", "*.rb")).select { |p| File.basename(p, ".rb").include?(pattern) }
+          return if found.empty?
+
+          lines << "## Channels (#{found.size})"
+          found.each do |path|
+            relative = path.sub("#{root}/", "")
+            lines << "- `#{relative}`"
+          end
+          lines << ""
+        rescue
+          nil
+        end
+
+        # --- AF11: Mailers ---
+        def discover_mailers(root, pattern, lines)
+          dir = File.join(root, "app", "mailers")
+          return unless Dir.exist?(dir)
+
+          found = Dir.glob(File.join(dir, "**", "*.rb")).select { |p| File.basename(p, ".rb").include?(pattern) }
+          return if found.empty?
+
+          lines << "## Mailers (#{found.size})"
+          found.each do |path|
+            relative = path.sub("#{root}/", "")
+            source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            methods = source.scan(/\A\s*def (\w+)/m).flatten.reject { |m| m == "initialize" }
+            lines << "- `#{relative}` — #{methods.join(', ')}" if methods.any?
+          end
+          lines << ""
+        rescue
+          nil
+        end
+
+        # --- AF9: Environment Dependencies ---
+        def discover_env_dependencies(root, pattern, matched_models, lines)
+          # Scan services, jobs, and model files for ENV references
+          dirs = %w[app/services app/jobs].map { |d| File.join(root, d) }.select { |d| Dir.exist?(d) }
+          env_vars = Set.new
+
+          dirs.each do |dir|
+            Dir.glob(File.join(dir, "**", "*.rb")).each do |path|
+              next unless File.basename(path, ".rb").include?(pattern) || path.downcase.include?(pattern)
+              source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+              source.scan(/ENV\[["']([^"']+)["']\]|ENV\.fetch\(["']([^"']+)["']\)/).each do |m|
+                env_vars << (m[0] || m[1])
+              end
+            end
+          end
+          return if env_vars.empty?
+
+          lines << "## Environment Dependencies"
+          env_vars.sort.each { |v| lines << "- `#{v}`" }
+          lines << ""
+        rescue
+          nil
+        end
       end
     end
   end

data/lib/rails_ai_context/tools/get_design_system.rb

@@ -72,6 +72,9 @@ module RailsAiContext
           # Icons
           lines.concat(render_icons(patterns))
 
+          # Animations
+          lines.concat(render_animations(patterns))
+
           # Design tokens
           lines.concat(render_tokens(dt))
         end
@@ -102,12 +105,14 @@ module RailsAiContext
             lines << "- **Borders:** #{scheme[:border_palette].first(4).join(', ')}"
           end
 
-          # Design token colors
+          # Design token colors (DS21: filter oklch noise from summary)
           if dt.is_a?(Hash) && !dt[:error]
             colors = dt.dig(:categorized, :colors) || {}
-            if colors.any?
+            # Filter oklch/complex values in non-full modes — show only hex/rgb/named
+            readable_colors = colors.reject { |_, v| v.to_s.match?(/oklch|calc|var\(/) }
+            if readable_colors.any?
               lines << "" << "### Token Colors"
-              colors.first(10).each { |name, value| lines << "- `#{name}`: #{value}" }
+              readable_colors.first(10).each { |name, value| lines << "- `#{name}`: #{value}" }
             end
           end
 
@@ -258,6 +263,19 @@ module RailsAiContext
           lines
         end
 
+        def render_animations(patterns)
+          anims = patterns[:animations]
+          return [] unless anims.is_a?(Hash) && anims.any?
+
+          lines = [ "## Animations & Transitions", "" ]
+          lines << "- Transitions: #{anims[:transitions].keys.join(', ')}" if anims[:transitions]&.any?
+          lines << "- Durations: #{anims[:durations].keys.join(', ')}" if anims[:durations]&.any?
+          lines << "- Animations: #{anims[:animates].keys.join(', ')}" if anims[:animates]&.any?
+          lines << "- Easing: #{anims[:easing].keys.join(', ')}" if anims[:easing]&.any?
+          lines << ""
+          lines
+        end
+
         def render_tokens(dt)
           return [] unless dt.is_a?(Hash) && !dt[:error]
 

data/lib/rails_ai_context/tools/validate.rb

@@ -602,7 +602,9 @@ module RailsAiContext
         model_data[:associations]&.each { |a| valid << a[:name]; valid << a[:foreign_key] if a[:foreign_key] }
         valid.merge(%w[id _destroy created_at updated_at])
 
-        # If model has JSONB/JSON columns, params may be stored as hash keys inside them — skip check
+        # If model has JSONB/JSON columns, permitted params likely go INTO those columns
+        # (e.g. Cook permits :product_details which is stored inside intake JSONB)
+        # Skip the entire check — too many false positives otherwise
         has_json_columns = table_data[:columns]&.any? { |c| %w[jsonb json].include?(c[:type]) }
         return warnings if has_json_columns
 
@@ -678,7 +680,7 @@ module RailsAiContext
           action = route[:action]
           next unless action
           unless actions.include?(action)
-            warnings << "route #{route[:verb]} #{route[:path]} \u2192 #{action} \u2014 action not found in #{ctrl_class}"
+            warnings << "route #{route[:verb]} #{route[:path]} \u2192 #{action} \u2014 action not found in #{ctrl_class}. Fix: add `def #{action}; end` to #{ctrl_class} or remove the route"
           end
         end
         warnings

data/lib/rails_ai_context/version.rb

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

data/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.crisnahine/rails-ai-context",
   "title": "Rails AI Context",
-  "description": "Auto-expose Rails app structure to AI via MCP. Zero config, 14 read-only tools.",
+  "description": "Auto-expose Rails app structure to AI via MCP. Zero config, 15 read-only tools, design system extraction.",
   "repository": {
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"

metadata

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