rails-ai-context 5.3.0 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9d802d024a373d0552ee2b70cf3d5d755fd79f951b8335da948563a7f488af4
-  data.tar.gz: fabf3246fb0df9a97294bca58dac86d4bccc7ffd881fb1da69dc262d03e43fba
+  metadata.gz: 43e8a71c793404bd950627b8f3319b4e909a0ba7a2cfe937a8d1027e2ede4af0
+  data.tar.gz: f296960edc1f3f336e90b9549618fd4b48d51d31330d95a65de9304ba47aa0af
 SHA512:
-  metadata.gz: 40fbc9d7455f857de366de800f91ddfa19b9b752cfced2905c2bedc0576a3d54ee4a4c89eccb701904b0eb6cb8babd106cb699182a5eab98981a02d60ff14d6f
-  data.tar.gz: e640c259017a222d43a32d15a8c7e70f9888eb3a8df3ad172159efa17371003196ade1f2bf561683a319fa4cebc6b16262f72aee56dea636d2be5fa0a5c7dba7
+  metadata.gz: bc10e825ef820ad955e89ded454469104160f954b967958866876794b1c114d9b708564e99781f1252cf4faa683d468bf5143823ee3418080de43ef745508ab2
+  data.tar.gz: 127d4159c5d88da79ae7fcb7389ffb84cca28621e0181da7b7e495e6af6fe0f8c0073b37dff3087a67be78c236e6f09e36aaef82e070461406e8a2027d88d2a8

data/CHANGELOG.md

@@ -5,6 +5,32 @@ 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.4.0] — 2026-04-08
+
+### Added — Phase 3: Dynamic VFS & Live Resource Architecture (Ground Truth Engine Blueprint #39)
+
+Live Virtual File System replaces static resource handling. Every MCP resource is introspected fresh on every request — zero stale data.
+
+- **VFS URI Dispatcher** (`lib/rails_ai_context/vfs.rb`) — Pattern-matched routing for `rails-ai-context://` URIs. Resolves models, controllers, controller actions, views, and routes. Each call introspects fresh. Path traversal protection for view reads.
+
+- **4 new MCP Resource Templates:**
+  - `rails-ai-context://controllers/{name}` — controller details with actions, filters, strong params
+  - `rails-ai-context://controllers/{name}/{action}` — action source code and applicable filters
+  - `rails-ai-context://views/{path}` — view template content (path traversal protected)
+  - `rails-ai-context://routes/{controller}` — live route map filtered by controller name
+
+- **MCP Controller** (`app/controllers/rails_ai_context/mcp_controller.rb`) — Native Rails controller for Streamable HTTP transport. Alternative to Rack middleware — integrates with Rails routing, authentication, and middleware stack. Mount via `mount RailsAiContext::Engine, at: "/mcp"`.
+
+- **output_schema on all 38 tools** — Default `MCP::Tool::OutputSchema` set via `BaseTool.inherited` hook. Every tool now declares its output format in the MCP protocol. Individual tools can override with custom schemas.
+
+- **Instrumentation** (`lib/rails_ai_context/instrumentation.rb`) — Bridges MCP gem instrumentation to `ActiveSupport::Notifications`. Events: `rails_ai_context.tools.call`, `rails_ai_context.resources.read`, etc. Subscribe with standard Rails notification patterns.
+
+- **Server instructions** — MCP server now includes `instructions:` field describing the ground truth engine capabilities.
+
+- **Enhanced LiveReload** — Full cache sweep on file changes via `reset_all_caches!` (includes AST, tool, and fingerprint caches).
+
+- **82 new specs** covering VFS resolution (models, controllers, actions, views, routes), instrumentation callback, McpController (thread safety, delegation, subclass isolation), resource templates (5 total), output_schema on all 38 tools, and server configuration.
+
 ## [5.3.0] — 2026-04-07
 
 ### Added — Phase 2: Cross-Tool Semantic Hydration (Ground Truth Engine Blueprint #38)

data/README.md

@@ -17,9 +17,10 @@
 [![Downloads](https://img.shields.io/gem/dt/rails-ai-context?color=blue)](https://rubygems.org/gems/rails-ai-context)
 [![CI](https://github.com/crisnahine/rails-ai-context/actions/workflows/ci.yml/badge.svg)](https://github.com/crisnahine/rails-ai-context/actions)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-green)](https://registry.modelcontextprotocol.io)
+<br>
 [![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-1731%20passing-brightgreen)](https://github.com/crisnahine/rails-ai-context/actions)
+[![Tests](https://img.shields.io/badge/Tests-1813%20passing-brightgreen)](https://github.com/crisnahine/rails-ai-context/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 </div>
@@ -66,7 +67,7 @@ rails-ai-context serve    # start MCP server
 
 </div>
 
-Now your AI doesn't guess — it **asks your app directly.** 38 tools that query your schema, models, routes, controllers, views, and conventions on demand. Model introspection uses Prism AST parsing — every result carries a `[VERIFIED]` or `[INFERRED]` confidence tag so AI knows what's ground truth and what needs runtime checking.
+Now your AI doesn't guess — it **asks your app directly.** 38 tools and 5 resource templates that query your schema, models, routes, controllers, views, and conventions on demand. Model introspection uses Prism AST parsing — every result carries a `[VERIFIED]` or `[INFERRED]` confidence tag so AI knows what's ground truth and what needs runtime checking.
 
 <br>
 
@@ -122,13 +123,13 @@ Compare what AI outputs with and without these tools wired in. The difference is
 
 <br>
 
-## Two ways to use it
+## Three ways to use it
 
 <table>
 <tr>
-<td width="50%">
+<td width="33%">
 
-### MCP Server
+### MCP Server (stdio)
 
 AI calls tools directly via the protocol. Auto-discovered through `.mcp.json`.
 
@@ -143,7 +144,21 @@ rails ai:serve
 ```
 
 </td>
-<td width="50%">
+<td width="33%">
+
+### MCP Server (HTTP)
+
+Mount inside your Rails app — inherits routing, auth, and middleware.
+
+```ruby
+# config/routes.rb
+mount RailsAiContext::Engine, at: "/mcp"
+```
+
+Native Rails controller transport. No separate process needed.
+
+</td>
+<td width="33%">
 
 ### CLI
 
@@ -342,6 +357,22 @@ Every tool is **read-only** and returns data verified against your actual app
 
 <br>
 
+## Live Resources (VFS)
+
+AI clients can also read structured data through **resource templates** — `rails-ai-context://` URIs that introspect fresh on every request. Zero stale data.
+
+| Resource Template | What it returns |
+|:------------------|:---------------|
+| `rails-ai-context://controllers/{name}` | Actions, inherited filters, strong params |
+| `rails-ai-context://controllers/{name}/{action}` | Action source code with applicable filters |
+| `rails-ai-context://views/{path}` | View template content (path traversal protected) |
+| `rails-ai-context://routes/{controller}` | Live route map filtered by controller |
+| `rails://models/{name}` | Per-model details: associations, validations, schema |
+
+Plus 9 static resources (schema, routes, conventions, gems, controllers, config, tests, migrations, engines) that AI clients read directly.
+
+<br>
+
 ## Anti-Hallucination Protocol
 
 Every generated context file ships with **6 rules that force AI verification** before writing code. The protocol targets the exact cognitive failures that produce confident-wrong code: statistical priors overriding observed facts, pattern completion beating verification, stale context lies.
@@ -376,14 +407,15 @@ Enabled by default. Disable with `config.anti_hallucination_rules = false` if yo
 ┌─────────────────────────────────────────────────────────┐
 │  rails-ai-context                                        │
 │  Prism AST parsing. Cached. Confidence-tagged results.    │
+│  VFS: rails-ai-context:// URIs introspected fresh.        │
 └────────┬──────────────────┬──────────────┬──────────────┘
          │                  │              │
          ▼                  ▼              ▼
 ┌──────────────────┐ ┌────────────┐ ┌────────────────────┐
 │  Static Files     │ │  MCP Server │ │  CLI Tools          │
 │  CLAUDE.md        │ │  38 tools   │ │  Same 38 tools      │
-│  .cursor/rules/   │ │  stdio/HTTP │ │  No server needed   │
-│  .github/instr... │ │  .mcp.json  │ │  rails 'ai:tool[X]' │
+│  .cursor/rules/   │ │  5 templates│ │  No server needed   │
+│  .github/instr... │ │  stdio/HTTP │ │  rails 'ai:tool[X]' │
 └──────────────────┘ └────────────┘ └────────────────────┘
 ```
 
@@ -458,6 +490,20 @@ end
 
 <br>
 
+## Observability
+
+Every MCP tool call and resource read fires an `ActiveSupport::Notifications` event. Subscribe with standard Rails patterns:
+
+```ruby
+ActiveSupport::Notifications.subscribe("rails_ai_context.tools.call") do |event|
+  Rails.logger.info "[MCP] #{event.payload[:method]} — #{event.duration}ms"
+end
+```
+
+Events: `rails_ai_context.tools.call`, `rails_ai_context.resources.read`, and more. All 38 tools declare `output_schema` in the MCP protocol, so clients know the response format before calling.
+
+<br>
+
 ## Requirements
 
 - **Ruby** >= 3.2 &nbsp;&nbsp; **Rails** >= 7.1
@@ -472,7 +518,7 @@ end
 ## About
 
 Built by a Rails developer with 10+ years of production experience.<br>
-1731 tests. 38 tools. 31 introspectors. Standalone or in-Gemfile.<br>
+1813 tests. 38 tools. 5 resource templates. 31 introspectors. Standalone or in-Gemfile.<br>
 MIT licensed. [Contributions welcome.](CONTRIBUTING.md)
 
 <br>

data/app/controllers/rails_ai_context/mcp_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Rails controller for serving MCP over Streamable HTTP.
+  # Alternative to the Rack middleware — integrates with Rails routing,
+  # authentication, and middleware stack.
+  #
+  # Mount in routes: mount RailsAiContext::Engine, at: "/mcp"
+  class McpController < ActionController::API
+    def handle
+      rack_response = self.class.mcp_transport.handle_request(request)
+      self.status = rack_response[0]
+      rack_response[1].each { |k, v| response.headers[k] = v }
+      self.response_body = rack_response[2]
+    end
+
+    class << self
+      # Class-level memoization — transport persists across requests.
+      # Thread-safe: MCP::Server and transport are stateless for reads.
+      def mcp_transport
+        @mcp_transport || @transport_mutex.synchronize do
+          @mcp_transport ||= begin
+            server = RailsAiContext::Server.new(Rails.application, transport: :http).build
+            MCP::Server::Transports::StreamableHTTPTransport.new(server)
+          end
+        end
+      end
+
+      def reset_transport!
+        @transport_mutex.synchronize { @mcp_transport = nil }
+      end
+
+      private
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@transport_mutex, Mutex.new)
+      end
+    end
+
+    @transport_mutex = Mutex.new
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+RailsAiContext::Engine.routes.draw do
+  match "/", to: "mcp#handle", via: :all
+end

data/docs/GUIDE.md

@@ -1010,6 +1010,17 @@ In addition to tools, the gem registers static MCP resources that AI clients can
 | `rails://engines` | Mounted engines with paths and descriptions (JSON) |
 | `rails://models/{name}` | Per-model details (resource template) |
 
+### Dynamic Resource Templates (VFS)
+
+Live resources introspected fresh on every request — zero stale data:
+
+| Resource Template | Description |
+|-------------------|-------------|
+| `rails-ai-context://controllers/{name}` | Controller details with actions, filters, strong params |
+| `rails-ai-context://controllers/{name}/{action}` | Specific action source code and applicable filters |
+| `rails-ai-context://views/{path}` | View template content (path traversal protected) |
+| `rails-ai-context://routes` | Live route map (optionally filter by controller) |
+
 ---
 
 ## MCP Server Setup
@@ -1126,6 +1137,17 @@ end
 
 Both transports are **read-only** — they expose the same 38 tools and never modify your app.
 
+### Controller Transport (Alternative)
+
+For tighter Rails integration (authentication, routing, middleware stack), mount the engine instead of using Rack middleware:
+
+```ruby
+# config/routes.rb
+mount RailsAiContext::Engine, at: "/mcp"
+```
+
+This provides a native Rails controller (`RailsAiContext::McpController`) that delegates to the Streamable HTTP transport.
+
 ---
 
 ## Configuration — All Options

data/lib/rails_ai_context/instrumentation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Bridges MCP gem instrumentation to ActiveSupport::Notifications.
+  # Enables Rails apps to subscribe to MCP events (tool calls, resource reads, etc.).
+  module Instrumentation
+    EVENT_PREFIX = "rails_ai_context"
+
+    # Returns a lambda for MCP::Configuration#instrumentation_callback.
+    # Instruments each MCP method call as an ActiveSupport::Notifications event.
+    def self.callback
+      ->(data) {
+        return unless defined?(ActiveSupport::Notifications)
+
+        method = data[:method] || "unknown"
+        event_name = "#{EVENT_PREFIX}.#{method.tr("/", ".")}"
+
+        ActiveSupport::Notifications.instrument(event_name, data)
+      }
+    end
+  end
+end

data/lib/rails_ai_context/live_reload.rb

@@ -53,7 +53,7 @@ module RailsAiContext
 
       @last_fingerprint = Fingerprinter.compute(app)
 
-      # Invalidate all tool caches
+      # Invalidate all tool caches (includes AstCache.clear)
       Tools::BaseTool.reset_all_caches!
 
       # Build a human-readable change summary

data/lib/rails_ai_context/resources.rb

@@ -70,6 +70,34 @@ module RailsAiContext
       mime_type: "application/json"
     ).freeze
 
+    CONTROLLER_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://controllers/{name}",
+      name: "Controller Details",
+      description: "Controller with actions, filters, strong params, and schema hints",
+      mime_type: "application/json"
+    ).freeze
+
+    CONTROLLER_ACTION_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://controllers/{name}/{action}",
+      name: "Controller Action",
+      description: "Source code and metadata for a specific controller action",
+      mime_type: "application/json"
+    ).freeze
+
+    VIEW_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://views/{path}",
+      name: "View Template",
+      description: "View template content for a specific path relative to app/views",
+      mime_type: "text/html"
+    ).freeze
+
+    ROUTES_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://routes/{controller}",
+      name: "Live Routes",
+      description: "Application routes introspected fresh on each request, optionally filtered by controller name",
+      mime_type: "application/json"
+    ).freeze
+
     class << self
       def static_resources
         STATIC_RESOURCES.map do |uri, meta|
@@ -83,7 +111,7 @@ module RailsAiContext
       end
 
       def resource_templates
-        [ MODEL_TEMPLATE ]
+        [ MODEL_TEMPLATE, CONTROLLER_TEMPLATE, CONTROLLER_ACTION_TEMPLATE, VIEW_TEMPLATE, ROUTES_TEMPLATE ]
       end
 
       def register(server)
@@ -100,6 +128,11 @@ module RailsAiContext
 
       def handle_read(params)
         uri = params[:uri]
+
+        # Delegate rails-ai-context:// URIs to the VFS dispatcher
+        return VFS.resolve(uri) if uri.start_with?("#{VFS::SCHEME}://")
+
+        # Legacy rails:// URI handling
         context = RailsAiContext.introspect
 
         if STATIC_RESOURCES.key?(uri)

data/lib/rails_ai_context/server.rb

@@ -67,11 +67,17 @@ module RailsAiContext
         end
       end
 
+      mcp_config = MCP::Configuration.new(
+        instrumentation_callback: Instrumentation.callback
+      )
+
       server = MCP::Server.new(
         name: config.server_name,
         version: config.server_version,
+        instructions: "Ground truth engine for Rails apps. Live Prism AST introspection. Zero stale data.",
         tools: active_tools(config) + validated_custom_tools,
-        resource_templates: Resources.resource_templates
+        resource_templates: Resources.resource_templates,
+        configuration: mcp_config
       )
 
       Resources.register(server)

data/lib/rails_ai_context/tools/base_tool.rb

@@ -8,6 +8,32 @@ module RailsAiContext
     # Inherits from the official MCP::Tool to get schema validation,
     # annotations, and protocol compliance for free.
     class BaseTool < MCP::Tool
+      # Default output schema for all tools. MCP::Tool.inherited resets
+      # @output_schema_value to nil on each subclass, so we re-set it
+      # via our own inherited hook.
+      DEFAULT_OUTPUT_SCHEMA = MCP::Tool::OutputSchema.new(
+        type: "object",
+        properties: {
+          content: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                type: { type: "string", enum: [ "text" ] },
+                text: { type: "string", description: "Tool response as Markdown-formatted text" }
+              },
+              required: [ "type", "text" ]
+            }
+          }
+        },
+        required: [ "content" ]
+      ).freeze
+
+      def self.inherited(subclass)
+        super
+        subclass.instance_variable_set(:@output_schema_value, DEFAULT_OUTPUT_SCHEMA)
+      end
+
       # Shared cache across all tool subclasses, protected by a Mutex
       # for thread safety in multi-threaded servers (e.g., Puma).
       SHARED_CACHE = { mutex: Mutex.new }

data/lib/rails_ai_context/version.rb

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

data/lib/rails_ai_context/vfs.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsAiContext
+  # Virtual File System — pattern-matched URI routing for MCP resources.
+  # Each resolve call introspects fresh (zero stale data).
+  module VFS
+    SCHEME = "rails-ai-context"
+
+    PATTERNS = [
+      { pattern: %r{\Arails-ai-context://controllers/([^/]+)/([^/]+)\z}, handler: :resolve_controller_action },
+      { pattern: %r{\Arails-ai-context://controllers/([^/]+)\z}, handler: :resolve_controller },
+      { pattern: %r{\Arails-ai-context://models/(.+)\z}, handler: :resolve_model },
+      { pattern: %r{\Arails-ai-context://views/(.+)\z}, handler: :resolve_view },
+      { pattern: %r{\Arails-ai-context://routes/(.+)\z}, handler: :resolve_routes }
+    ].freeze
+
+    class << self
+      # Resolve a rails-ai-context:// URI to MCP resource content.
+      # Returns an array of content hashes: [{uri:, mime_type:, text:}]
+      def resolve(uri)
+        PATTERNS.each do |entry|
+          match = uri.match(entry[:pattern])
+          next unless match
+
+          return send(entry[:handler], uri, *match.captures)
+        end
+
+        raise RailsAiContext::Error, "Unknown VFS URI: #{uri}"
+      end
+
+      private
+
+      def resolve_model(uri, name)
+        context = RailsAiContext.introspect
+        models = context[:models] || {}
+
+        # Case-insensitive lookup
+        key = models.keys.find { |k| k.to_s.casecmp?(name) } || name
+        data = models[key]
+
+        unless data
+          available = models.keys.sort.first(20)
+          content = JSON.pretty_generate(error: "Model '#{name}' not found", available: available)
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        # Enrich with schema columns if available
+        table_name = data[:table_name]
+        schema = context.dig(:schema, :tables, table_name) if table_name
+        enriched = data.merge(schema: schema).compact
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(enriched) } ]
+      end
+
+      def resolve_controller(uri, name)
+        context = RailsAiContext.introspect
+        controllers = context.dig(:controllers, :controllers) || {}
+
+        # Flexible matching: "posts", "PostsController", "postscontroller"
+        input_snake = name.underscore.delete_suffix("_controller")
+        key = controllers.keys.find { |k|
+          k.underscore.delete_suffix("_controller") == input_snake ||
+            k.downcase.delete_suffix("controller") == name.downcase.delete_suffix("controller")
+        }
+
+        unless key
+          available = controllers.keys.sort.first(20)
+          content = JSON.pretty_generate(error: "Controller '#{name}' not found", available: available)
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(controllers[key]) } ]
+      end
+
+      def resolve_controller_action(uri, controller_name, action_name)
+        context = RailsAiContext.introspect
+        controllers = context.dig(:controllers, :controllers) || {}
+
+        input_snake = controller_name.underscore.delete_suffix("_controller")
+        key = controllers.keys.find { |k|
+          k.underscore.delete_suffix("_controller") == input_snake
+        }
+
+        unless key
+          content = JSON.pretty_generate(error: "Controller '#{controller_name}' not found")
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        info = controllers[key]
+        actions = info[:actions] || []
+        action = actions.find { |a| a.to_s.casecmp?(action_name) }
+
+        unless action
+          content = JSON.pretty_generate(error: "Action '#{action_name}' not found in #{key}", available: actions)
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        # Build action-specific data
+        action_data = {
+          controller: key,
+          action: action.to_s,
+          filters: (info[:filters] || []).select { |f|
+            if f[:only]&.any?
+              f[:only].map(&:to_s).include?(action.to_s)
+            elsif f[:except]&.any?
+              !f[:except].map(&:to_s).include?(action.to_s)
+            else
+              true
+            end
+          },
+          strong_params: info[:strong_params]
+        }.compact
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(action_data) } ]
+      end
+
+      def resolve_view(uri, path)
+        # Block path traversal
+        if path.include?("..") || path.start_with?("/")
+          raise RailsAiContext::Error, "Path not allowed: #{path}"
+        end
+
+        views_dir = Rails.root.join("app", "views")
+        full_path = views_dir.join(path)
+
+        unless File.exist?(full_path)
+          content = JSON.pretty_generate(error: "View not found: #{path}")
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        # Verify resolved path is still under views_dir
+        unless File.realpath(full_path).start_with?(File.realpath(views_dir))
+          raise RailsAiContext::Error, "Path not allowed: #{path}"
+        end
+
+        max_size = RailsAiContext.configuration.max_file_size
+        if File.size(full_path) > max_size
+          content = JSON.pretty_generate(error: "File too large: #{path} (#{File.size(full_path)} bytes)")
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        view_content = RailsAiContext::SafeFile.read(full_path) || ""
+        mime = path.end_with?(".rb") ? "text/x-ruby" : "text/html"
+        [ { uri: uri, mime_type: mime, text: view_content } ]
+      end
+
+      def resolve_routes(uri, controller)
+        context = RailsAiContext.introspect
+        routes_data = context[:routes] || {}
+
+        filtered = (routes_data[:routes] || []).select { |r|
+          r[:controller].to_s.include?(controller)
+        }
+        data = routes_data.merge(routes: filtered, filtered_by: controller)
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(data) } ]
+      end
+    end
+  end
+end

data/lib/rails_ai_context.rb

@@ -3,7 +3,7 @@
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-loader.inflector.inflect("devops_introspector" => "DevOpsIntrospector", "cli" => "CLI")
+loader.inflector.inflect("devops_introspector" => "DevOpsIntrospector", "cli" => "CLI", "vfs" => "VFS")
 loader.ignore("#{__dir__}/generators")
 loader.ignore("#{__dir__}/rails-ai-context.rb")
 loader.setup

data/server.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.3.0",
+  "version": "5.4.0",
   "packages": [
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.3.0/rails-ai-context-mcp.mcpb",
+      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.4.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.3.0
+  version: 5.4.0
 platform: ruby
 authors:
 - crisnahine
@@ -207,6 +207,8 @@ files:
 - README.md
 - Rakefile
 - SECURITY.md
+- app/controllers/rails_ai_context/mcp_controller.rb
+- config/routes.rb
 - demo/demo-trace.gif
 - demo/demo-trace.tape
 - demo/demo.gif
@@ -229,6 +231,7 @@ files:
 - 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/instrumentation.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
@@ -333,6 +336,7 @@ files:
 - lib/rails_ai_context/tools/session_context.rb
 - lib/rails_ai_context/tools/validate.rb
 - lib/rails_ai_context/version.rb
+- lib/rails_ai_context/vfs.rb
 - lib/rails_ai_context/watcher.rb
 - server.json
 homepage: https://github.com/crisnahine/rails-ai-context