rails-ai-context 5.2.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1dd01df89a380a86e14436ae9275c5db3f88b0e4fc56ea6df7d308f2c468472
-  data.tar.gz: 6f2efe8319fa533b8ea19cc0ace32460b24cb9b96873af0956c4b126041cd14b
+  metadata.gz: a9d802d024a373d0552ee2b70cf3d5d755fd79f951b8335da948563a7f488af4
+  data.tar.gz: fabf3246fb0df9a97294bca58dac86d4bccc7ffd881fb1da69dc262d03e43fba
 SHA512:
-  metadata.gz: 1447735cb99e717f1fa43a1fa54cc89fe1d6e0a836fcf156a7a66cede53c321328fbe4088a0c72103d91fe9c49de88f537cb59cddcbe1782773416892f76c728
-  data.tar.gz: 57b9e93748454c414563d453661eb4b51f94a063f15ac12a7073d6695b3cbc1e7fb1db323be3972ac1f830c1b21d73fcc65dc8fc1d5f170c8787cd9c8031881d
+  metadata.gz: 40fbc9d7455f857de366de800f91ddfa19b9b752cfced2905c2bedc0576a3d54ee4a4c89eccb701904b0eb6cb8babd106cb699182a5eab98981a02d60ff14d6f
+  data.tar.gz: e640c259017a222d43a32d15a8c7e70f9888eb3a8df3ad172159efa17371003196ade1f2bf561683a319fa4cebc6b16262f72aee56dea636d2be5fa0a5c7dba7

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).
 
+## [5.3.0] — 2026-04-07
+
+### Added — Phase 2: Cross-Tool Semantic Hydration (Ground Truth Engine Blueprint #38)
+
+Controller and view tools now automatically inject schema hints for referenced models, eliminating the need for follow-up tool calls.
+
+- **SchemaHint** (`lib/rails_ai_context/schema_hint.rb`) — Immutable `Data.define` value object carrying model ground truth: table, columns, associations, validations, primary key, and `[VERIFIED]`/`[INFERRED]` confidence tag.
+
+- **HydrationResult** — Wraps hints + warnings for downstream formatting.
+
+- **SchemaHintBuilder** (`lib/rails_ai_context/hydrators/schema_hint_builder.rb`) — Resolves model names to `SchemaHint` objects from cached introspection context. Case-insensitive lookup, batch builder with configurable cap.
+
+- **HydrationFormatter** (`lib/rails_ai_context/hydrators/hydration_formatter.rb`) — Renders `SchemaHint` objects as compact Markdown `## Schema Hints` sections with columns (capped at 10), associations, and validations.
+
+- **ControllerHydrator** (`lib/rails_ai_context/hydrators/controller_hydrator.rb`) — Parses controller source via Prism AST to detect model references (constant receivers, `params.require` keys, ivar writes), then builds schema hints.
+
+- **ViewHydrator** (`lib/rails_ai_context/hydrators/view_hydrator.rb`) — Maps instance variable names to models by convention (`@post` → `Post`, `@posts` → `Post`). Filters framework ivars (page, query, flash, etc.).
+
+- **ModelReferenceListener** (`lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb`) — Prism Dispatcher listener for controller-specific model detection. Not registered in `LISTENER_MAP` — used standalone by `ControllerHydrator`.
+
+- **Tool integrations:**
+  - `GetControllers` — schema hints injected into both action source and controller overview
+  - `GetContext` — hydrates combined controller+view ivars in action context mode
+  - `GetView` — hydrates instance variables from view templates in standard detail
+
+- **Configuration:** `hydration_enabled` (default: true), `hydration_max_hints` (default: 5). Both YAML-configurable.
+
+- **65 new specs** covering SchemaHint, HydrationResult, SchemaHintBuilder, HydrationFormatter, ModelReferenceListener, ControllerHydrator, ViewHydrator, tool-level hydration integration (GetControllers, GetView), and configuration (defaults, YAML loading, max_hints propagation).
+
 ## [5.2.0] — 2026-04-07
 
 ### Added — Phase 1: Prism AST Foundation (Ground Truth Engine Blueprint #36)

data/README.md

@@ -19,7 +19,7 @@
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-green)](https://registry.modelcontextprotocol.io)
 [![Ruby](https://img.shields.io/badge/Ruby-3.2%20%7C%203.3%20%7C%203.4-CC342D)](https://github.com/crisnahine/rails-ai-context)
 [![Rails](https://img.shields.io/badge/Rails-7.1%20%7C%207.2%20%7C%208.0-CC0000)](https://github.com/crisnahine/rails-ai-context)
-[![Tests](https://img.shields.io/badge/Tests-1668%20passing-brightgreen)](https://github.com/crisnahine/rails-ai-context/actions)
+[![Tests](https://img.shields.io/badge/Tests-1731%20passing-brightgreen)](https://github.com/crisnahine/rails-ai-context/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 </div>
@@ -472,7 +472,7 @@ end
 ## About
 
 Built by a Rails developer with 10+ years of production experience.<br>
-1668 tests. 38 tools. 31 introspectors. Standalone or in-Gemfile.<br>
+1731 tests. 38 tools. 31 introspectors. Standalone or in-Gemfile.<br>
 MIT licensed. [Contributions welcome.](CONTRIBUTING.md)
 
 <br>

data/docs/GUIDE.md

@@ -431,7 +431,7 @@ rails_get_routes(detail: "standard", limit: 20, offset: 100)
 
 ### rails_get_controllers
 
-Returns controller details: actions, filters, strong params, concerns.
+Returns controller details: actions, filters, strong params, concerns. Automatically includes **Schema Hints** for models referenced in the controller (via Prism AST detection).
 
 **Parameters:**
 
@@ -549,7 +549,7 @@ rails_get_stimulus(detail: "full")
 
 ### rails_get_view
 
-Returns view template contents, partials, and Stimulus controller references.
+Returns view template contents, partials, and Stimulus controller references. In standard detail, includes **Schema Hints** for models inferred from instance variables.
 
 **Parameters:**
 
@@ -946,7 +946,7 @@ rails_get_turbo_map(controller: "messages", detail: "full")
 
 ### rails_get_context
 
-Get cross-layer context in a single call — combines schema, model, controller, routes, views, stimulus, and tests. Use when you need full context for implementing a feature or modifying an action.
+Get cross-layer context in a single call — combines schema, model, controller, routes, views, stimulus, and tests. Automatically includes **Schema Hints** for models referenced in controller/view code. Use when you need full context for implementing a feature or modifying an action.
 
 **Parameters:**
 
@@ -1275,6 +1275,8 @@ end
 | `server_version` | String | gem version | MCP server version |
 | `generate_root_files` | Boolean | `true` | Generate root files (CLAUDE.md, etc.) — set `false` for split rules only |
 | `anti_hallucination_rules` | Boolean | `true` | Embed 6-rule Anti-Hallucination Protocol in generated context files — set `false` to skip |
+| `hydration_enabled` | Boolean | `true` | Inject schema hints into controller/view tool responses |
+| `hydration_max_hints` | Integer | `5` | Max schema hints per tool response |
 | `max_file_size` | Integer | `5_000_000` | Per-file read limit for tools (5MB) |
 | `max_test_file_size` | Integer | `1_000_000` | Test file read limit (1MB) |
 | `max_schema_file_size` | Integer | `10_000_000` | schema.rb / structure.sql parse limit (10MB) |

data/lib/rails_ai_context/configuration.rb

@@ -23,6 +23,7 @@ module RailsAiContext
       max_view_file_size max_search_results max_validate_files
       query_timeout query_row_limit query_redacted_columns allow_query_in_production
       log_lines introspectors
+      hydration_enabled hydration_max_hints
     ].freeze
 
     # Load configuration from a YAML file, applying values to the current config instance.
@@ -211,6 +212,10 @@ module RailsAiContext
     # Log reading settings (rails_read_logs)
     attr_accessor :log_lines                  # Default lines to tail (default: 50)
 
+    # Hydration: inject schema hints into controller/view tool responses
+    attr_accessor :hydration_enabled          # Enable/disable hydration (default: true)
+    attr_accessor :hydration_max_hints        # Max schema hints per response (default: 5)
+
     def initialize
       @server_name         = "rails-ai-context"
       @introspectors       = PRESETS[:full].dup
@@ -267,6 +272,8 @@ module RailsAiContext
       ]
       @allow_query_in_production = false
       @log_lines                = 50
+      @hydration_enabled        = true
+      @hydration_max_hints      = 5
     end
 
     def preset=(name)

data/lib/rails_ai_context/hydration_result.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Wraps hydration output: hints for detected models + any warnings.
+  HydrationResult = Data.define(:hints, :warnings) do
+    def initialize(hints: [], warnings: [])
+      super
+    end
+
+    def any?
+      hints.any?
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/controller_hydrator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Parses a controller source file via Prism AST, detects model
+    # references, and builds SchemaHint objects for each detected model.
+    class ControllerHydrator
+      # Hydrate a controller file with schema hints.
+      # Returns a HydrationResult with hints for all detected models.
+      def self.call(source_path, context:)
+        return HydrationResult.new unless source_path && File.exist?(source_path)
+        return HydrationResult.new if File.size(source_path) > RailsAiContext.configuration.max_file_size
+
+        model_names = detect_model_references(source_path)
+        return HydrationResult.new if model_names.empty?
+
+        hints = SchemaHintBuilder.build_many(model_names, context: context, max: RailsAiContext.configuration.hydration_max_hints)
+
+        warnings = []
+        unresolved = model_names - hints.map(&:model_name)
+        unresolved.each do |name|
+          warnings << "Model '#{name}' referenced but not found in introspection data"
+        end
+
+        HydrationResult.new(hints: hints, warnings: warnings)
+      rescue => e
+        $stderr.puts "[rails-ai-context] ControllerHydrator failed: #{e.message}" if ENV["DEBUG"]
+        HydrationResult.new
+      end
+
+      # Detect model names referenced in a controller source file using Prism AST.
+      def self.detect_model_references(source_path)
+        parse_result = AstCache.parse(source_path)
+        dispatcher = Prism::Dispatcher.new
+        listener = Introspectors::Listeners::ModelReferenceListener.new
+
+        events = []
+        events << :on_call_node_enter if listener.respond_to?(:on_call_node_enter)
+        events << :on_instance_variable_write_node_enter if listener.respond_to?(:on_instance_variable_write_node_enter)
+        dispatcher.register(listener, *events)
+
+        dispatcher.dispatch(parse_result.value)
+        listener.results
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_model_references failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+      private_class_method :detect_model_references
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/hydration_formatter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Formats SchemaHint objects into Markdown for tool output.
+    class HydrationFormatter
+      # Format a HydrationResult into a Markdown section.
+      def self.format(hydration_result)
+        return "" unless hydration_result&.any?
+
+        lines = [ "## Schema Hints", "" ]
+        hydration_result.hints.each do |hint|
+          lines << format_hint(hint)
+          lines << ""
+        end
+
+        if hydration_result.warnings.any?
+          hydration_result.warnings.each { |w| lines << "_#{w}_" }
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      # Format a single SchemaHint as a compact Markdown block.
+      def self.format_hint(hint)
+        lines = []
+        lines << "### #{hint.model_name} #{hint.confidence}"
+        lines << "**Table:** `#{hint.table_name}` (pk: `#{hint.primary_key}`)"
+
+        if hint.columns.any?
+          col_summary = hint.columns.first(10).map { |c|
+            "`#{c[:name]}` #{c[:type]}#{c[:null] == false ? ' NOT NULL' : ''}"
+          }
+          col_summary << "... #{hint.columns.size - 10} more" if hint.columns.size > 10
+          lines << "**Columns:** #{col_summary.join(', ')}"
+        end
+
+        if hint.associations.any?
+          assoc_list = hint.associations.map { |a| "`#{a[:type]}` :#{a[:name]}" }
+          lines << "**Associations:** #{assoc_list.join(', ')}"
+        end
+
+        if hint.validations.any?
+          val_list = hint.validations.map { |v|
+            attrs = v[:attributes]&.join(", ") || ""
+            "#{v[:kind]}(#{attrs})"
+          }
+          lines << "**Validations:** #{val_list.join(', ')}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/schema_hint_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Builds SchemaHint objects from cached introspection context.
+    # Single point of truth for resolving a model name into a
+    # structured hydration payload.
+    class SchemaHintBuilder
+      # Build a SchemaHint for a single model name.
+      # Returns nil if the model is not found in context.
+      def self.build(model_name, context:)
+        models_data = context[:models]
+        schema_data = context[:schema]
+        return nil unless models_data.is_a?(Hash) && schema_data.is_a?(Hash)
+
+        # Find model in models context (case-insensitive)
+        model_key = models_data.keys.find { |k| k.to_s.casecmp?(model_name) }
+        return nil unless model_key
+
+        model_info = models_data[model_key]
+        return nil unless model_info.is_a?(Hash)
+
+        table_name = model_info[:table_name]
+        table_data = schema_data.dig(:tables, table_name) if table_name
+
+        columns = if table_data
+          (table_data[:columns] || []).map do |col|
+            { name: col[:name], type: col[:type], null: col[:null] }.compact
+          end
+        else
+          []
+        end
+
+        associations = (model_info[:associations] || []).map do |assoc|
+          {
+            name: assoc[:name],
+            type: assoc[:type],
+            class_name: assoc[:class_name],
+            foreign_key: assoc[:foreign_key]
+          }.compact
+        end
+
+        validations = (model_info[:validations] || []).map do |val|
+          {
+            kind: val[:kind],
+            attributes: val[:attributes]
+          }.compact
+        end
+
+        primary_key = table_data&.dig(:primary_key) || "id"
+
+        # Confidence: verified if we have both model data and schema table
+        confidence = table_data ? "[VERIFIED]" : "[INFERRED]"
+
+        SchemaHint.new(
+          model_name: model_key.to_s,
+          table_name: table_name.to_s,
+          columns: columns,
+          associations: associations,
+          validations: validations,
+          primary_key: primary_key.to_s,
+          confidence: confidence
+        )
+      end
+
+      # Build SchemaHints for multiple model names.
+      # Returns only the ones that resolved successfully.
+      def self.build_many(model_names, context:, max: 5)
+        model_names.first(max).filter_map { |name| build(name, context: context) }
+      end
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/view_hydrator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Resolves instance variable references in views to model schema hints.
+    # Maps @post → Post, @posts → Post (singularized), etc.
+    class ViewHydrator
+      # Hydrate view instance variables with schema hints.
+      # ivar_names: array of instance variable names (without @) used in a view.
+      # Returns a HydrationResult with hints for resolved models.
+      def self.call(ivar_names, context:)
+        return HydrationResult.new if ivar_names.nil? || ivar_names.empty?
+
+        model_names = ivar_names.filter_map { |ivar| ivar_to_model_name(ivar) }.uniq
+        return HydrationResult.new if model_names.empty?
+
+        hints = SchemaHintBuilder.build_many(model_names, context: context, max: RailsAiContext.configuration.hydration_max_hints)
+
+        warnings = []
+        unresolved = model_names - hints.map(&:model_name)
+        unresolved.each do |name|
+          warnings << "@#{name.underscore} used in view but '#{name}' model not found"
+        end
+
+        HydrationResult.new(hints: hints, warnings: warnings)
+      rescue => e
+        $stderr.puts "[rails-ai-context] ViewHydrator failed: #{e.message}" if ENV["DEBUG"]
+        HydrationResult.new
+      end
+
+      # Convert an instance variable name to a model name by convention.
+      # @post → "Post", @posts → "Post", @current_user → "User"
+      def self.ivar_to_model_name(ivar_name)
+        name = ivar_name.to_s
+        # Skip framework/common non-model ivars
+        return nil if SKIP_IVARS.include?(name)
+
+        # Singularize and classify: "posts" → "Post", "order_items" → "OrderItem"
+        name.singularize.camelize
+      rescue StandardError
+        nil
+      end
+      private_class_method :ivar_to_model_name
+
+      SKIP_IVARS = %w[
+        page per_page total_count total_pages
+        query search filter sort order
+        flash notice alert errors
+        breadcrumbs tabs menu
+        title description meta
+        current_page pagy
+        output_buffer virtual_path _request
+      ].to_set.freeze
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # Prism Dispatcher listener that detects model references in controller source.
+      # Extracts constant names used as method receivers (Post.find, Post.new),
+      # params.require(:post) keys, and instance variable write targets.
+      #
+      # Not registered in SourceIntrospector::LISTENER_MAP — used standalone
+      # by ControllerHydrator since model references are controller-specific.
+      class ModelReferenceListener < BaseListener
+        attr_reader :constant_references, :require_keys, :ivar_models
+
+        def initialize
+          super
+          @constant_references = []
+          @require_keys = []
+          @ivar_models = {}
+        end
+
+        # Detect: Post.find, Post.where, Post.new, Post.create, etc.
+        # Detect: params.require(:post)
+        def on_call_node_enter(node)
+          extract_constant_receiver(node)
+          extract_params_require(node)
+        end
+
+        # Detect: @post = Post.new(...), @post = Post.find(...)
+        def on_instance_variable_write_node_enter(node)
+          extract_ivar_model(node)
+        end
+
+        def results
+          model_names = Set.new
+
+          # Constant receivers: Post.find → "Post"
+          @constant_references.each { |name| model_names << name }
+
+          # params.require(:post) → "Post"
+          @require_keys.each { |key| model_names << key.to_s.classify }
+
+          # @post = Post.new → "Post"
+          @ivar_models.each_value { |name| model_names << name }
+
+          model_names.reject { |n| framework_constant?(n) }.sort
+        end
+
+        private
+
+        def extract_constant_receiver(node)
+          receiver = node.receiver
+          return unless receiver
+
+          case receiver
+          when Prism::ConstantReadNode
+            @constant_references << receiver.name.to_s
+          when Prism::ConstantPathNode
+            # Handles Namespaced::Model.find
+            @constant_references << constant_path_string(receiver)
+          end
+        end
+
+        def extract_params_require(node)
+          return unless node.name == :require
+          receiver = node.receiver
+          return unless receiver.is_a?(Prism::CallNode) && receiver.name == :params && receiver.receiver.nil?
+
+          arg = node.arguments&.arguments&.first
+          case arg
+          when Prism::SymbolNode then @require_keys << arg.value
+          when Prism::StringNode then @require_keys << arg.unescaped
+          end
+        end
+
+        def extract_ivar_model(node)
+          value = node.value
+          return unless value.is_a?(Prism::CallNode)
+
+          receiver = value.receiver
+          name = case receiver
+          when Prism::ConstantReadNode then receiver.name.to_s
+          when Prism::ConstantPathNode then constant_path_string(receiver)
+          end
+          return unless name
+
+          @ivar_models[node.name.to_s] = name
+        end
+
+        FRAMEWORK_CONSTANTS = %w[
+          ApplicationController ActionController ActionDispatch
+          ActiveRecord ActiveSupport Rails ApplicationRecord
+          ActionView ActionMailer ActiveJob ActiveStorage
+          ActionCable ActionMailbox ActionText Turbo
+        ].to_set.freeze
+
+        def framework_constant?(name)
+          root = name.split("::").first
+          FRAMEWORK_CONSTANTS.include?(root)
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_context/schema_hint.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Structured hydration payload representing a model's ground truth.
+  # Used by hydrators to inject cross-tool context into controller
+  # and view tool responses. Immutable value object via Data.define.
+  SchemaHint = Data.define(
+    :model_name,    # "Post"
+    :table_name,    # "posts"
+    :columns,       # [{name: "title", type: "string", null: false}, ...]
+    :associations,  # [{name: "comments", type: "has_many", class_name: "Comment"}, ...]
+    :validations,   # [{kind: "presence", attributes: ["title"]}, ...]
+    :primary_key,   # "id"
+    :confidence     # "[VERIFIED]" or "[INFERRED]"
+  ) do
+    def verified?
+      confidence == "[VERIFIED]"
+    end
+
+    def column_names
+      columns.map { |c| c[:name] }
+    end
+
+    def association_names
+      associations.map { |a| a[:name] }
+    end
+  end
+end

data/lib/rails_ai_context/tools/get_context.rb

@@ -109,6 +109,17 @@ module RailsAiContext
         ivar_check = cross_reference_ivars(ctrl_ivars, view_ivars, rendered_templates: other_templates)
         lines << "" << ivar_check if ivar_check
 
+        # Hydrate: inject schema hints for models referenced in controller + view ivars
+        if RailsAiContext.configuration.hydration_enabled
+          all_ivars = (ctrl_ivars | view_ivars).to_a
+          hydration = Hydrators::ViewHydrator.call(all_ivars, context: cached_context)
+          hydration_text = Hydrators::HydrationFormatter.format(hydration)
+          # Skip if get_controllers already injected schema hints
+          unless hydration_text.empty? || lines.any? { |l| l.include?("## Schema Hints") }
+            lines << "" << hydration_text
+          end
+        end
+
         text_response(lines.join("\n"))
       rescue => e
         text_response("Error assembling context: #{e.message}")

data/lib/rails_ai_context/tools/get_controllers.rb

@@ -285,6 +285,13 @@ module RailsAiContext
           end
         end
 
+        # Hydrate with schema hints for models referenced in this action
+        if RailsAiContext.configuration.hydration_enabled
+          hydration = Hydrators::ControllerHydrator.call(source_path.to_s, context: cached_context)
+          hydration_text = Hydrators::HydrationFormatter.format(hydration)
+          lines << "" << hydration_text unless hydration_text.empty?
+        end
+
         lines.join("\n")
       end
 
@@ -519,6 +526,14 @@ module RailsAiContext
           info[:turbo_stream_actions].each { |a| lines << "- `#{a}`" }
         end
 
+        # Hydrate with schema hints for models referenced in this controller
+        if RailsAiContext.configuration.hydration_enabled
+          source_path = Rails.root.join("app", "controllers", "#{name.underscore}.rb")
+          hydration = Hydrators::ControllerHydrator.call(source_path.to_s, context: cached_context)
+          hydration_text = Hydrators::HydrationFormatter.format(hydration)
+          lines << "" << hydration_text unless hydration_text.empty?
+        end
+
         # Cross-reference hints
         ctrl_path = name.underscore.delete_suffix("_controller")
         model_name = ctrl_path.split("/").last.singularize.camelize

data/lib/rails_ai_context/tools/get_view.rb

@@ -153,6 +153,20 @@ module RailsAiContext
             end
             lines << ""
           end
+
+          # Hydrate: inject schema hints for models inferred from view instance variables
+          if RailsAiContext.configuration.hydration_enabled && controller
+            all_ivars = []
+            templates.each do |path, _meta|
+              content = read_view_content(path)
+              content.scan(/@(\w+)/).flatten.each { |v| all_ivars << v }
+            end
+            all_ivars.uniq!
+            hydration = Hydrators::ViewHydrator.call(all_ivars, context: cached_context)
+            hydration_text = Hydrators::HydrationFormatter.format(hydration)
+            lines << hydration_text << "" unless hydration_text.empty?
+          end
+
           text_response(lines.join("\n"))
 
         when "full"

data/lib/rails_ai_context/version.rb

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

data/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.2.0",
+  "version": "5.3.0",
   "packages": [
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.2.0/rails-ai-context-mcp.mcpb",
-      "fileSha256": "PENDING_RELEASE_BUILD",
+      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.3.0/rails-ai-context-mcp.mcpb",
+      "fileSha256": "0000000000000000000000000000000000000000000000000000000000000000",
       "transport": {
         "type": "stdio"
       }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 5.3.0
 platform: ruby
 authors:
 - crisnahine
@@ -224,6 +224,11 @@ files:
 - lib/rails_ai_context/doctor.rb
 - lib/rails_ai_context/engine.rb
 - lib/rails_ai_context/fingerprinter.rb
+- lib/rails_ai_context/hydration_result.rb
+- lib/rails_ai_context/hydrators/controller_hydrator.rb
+- lib/rails_ai_context/hydrators/hydration_formatter.rb
+- lib/rails_ai_context/hydrators/schema_hint_builder.rb
+- lib/rails_ai_context/hydrators/view_hydrator.rb
 - lib/rails_ai_context/introspector.rb
 - lib/rails_ai_context/introspectors/action_mailbox_introspector.rb
 - lib/rails_ai_context/introspectors/action_text_introspector.rb
@@ -248,6 +253,7 @@ files:
 - lib/rails_ai_context/introspectors/listeners/enums_listener.rb
 - lib/rails_ai_context/introspectors/listeners/macros_listener.rb
 - lib/rails_ai_context/introspectors/listeners/methods_listener.rb
+- lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb
 - lib/rails_ai_context/introspectors/listeners/scopes_listener.rb
 - lib/rails_ai_context/introspectors/listeners/validations_listener.rb
 - lib/rails_ai_context/introspectors/middleware_introspector.rb
@@ -270,6 +276,7 @@ files:
 - lib/rails_ai_context/middleware.rb
 - lib/rails_ai_context/resources.rb
 - lib/rails_ai_context/safe_file.rb
+- lib/rails_ai_context/schema_hint.rb
 - lib/rails_ai_context/serializers/claude_rules_serializer.rb
 - lib/rails_ai_context/serializers/claude_serializer.rb
 - lib/rails_ai_context/serializers/compact_serializer_helper.rb