rails-ai-context 5.11.2 → 5.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c22976350fb7eb968d01a1da8f99452670b331026d838953474054bad6cf7c3a
-  data.tar.gz: bc0d990afec5122a1a0bee44895dfc9cbd33675c2b8960346a79c60b288e7e4b
+  metadata.gz: 4544796594e923abe87c73ee94e07d87c3cec17aa0df7ad2d631dad8fbb4fee5
+  data.tar.gz: 4a41fc88963c28d5f3725ca1f6899c18d2d5b65a9ab201b9210d76f340e8229b
 SHA512:
-  metadata.gz: 52409e4462a56f2f4e1b1a62d15f9a0972711beb48212913578b0935b9b9522610e522a4cb02a51895b0df247572d8d2774b1fd93ac8f43b2f38976db6c0de7c
-  data.tar.gz: 04fa95c29a3b99c18261ae5f401f16158359638c14a017193ea6239ad8501b00ed72c6551fde2987ad83731fa2c109ab87138e3b8c0d9f58d2629c4ae9fb5d87
+  metadata.gz: 5bb1a0735533dcac1f9b35e639e15feb46c0f55e72686db352d3f312ccb737392f3783fd931ce0403141ccdb0a4bd46d95d85455519d0ebdb9e21a30c23d9d7d
+  data.tar.gz: 03cc5484cc2774320155ac1272564d58b82e5418a1a8e815f88e32fd7ed849a795f939fb32823beb53557a514050336f239c62bf9f06c0314ec8d96b23eb60cb

data/CHANGELOG.md

@@ -5,6 +5,28 @@ 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.12.0] - 2026-06-29
+
+### Fixed
+
+Live-usage audit of the full MCP surface (all 38 tools over stdio + HTTP, the CLI tool runner, and the 9 resources / 5 resource templates) against a real Rails 8 app surfaced 15 correctness and edge-case defects, now fixed:
+
+- **`rails_get_schema` (and every schema-backed tool) now reads the live database.** The schema introspector treated `ActiveRecord::Base.connected?` as "is a DB reachable", but that is `false` on a freshly booted server before any query runs, so it silently fell back to static `schema.rb` parsing -- which omits the implicit `id` primary key and reports schema.rb-approximate types. It now probes the connection (`SELECT 1`) and uses live column metadata, falling back to static parsing only when the database is genuinely unreachable. `rails_get_model_details`, `rails_get_context`, `rails_get_controllers` schema hints, and `rails_analyze_feature` all benefit.
+- **`rails_get_view`** resolves a logical `controller/action` path (e.g. `posts/index`) to its template instead of reporting "View not found" for a file it then lists in the same hint.
+- **`rails_diagnose`** classifies Ruby 3.4+ `undefined method 'x' for an instance of Y` errors (and other bare, class-prefix-less messages) by inferring the exception class from the message signature.
+- **`rails_get_turbo_map`** now reports `.turbo_stream.erb` response templates and their stream actions. Apps using the common scaffold-style Turbo Stream pattern no longer show "No Turbo Streams or Frames detected".
+- **`rails_get_partial_interface`** detects implicit object/collection render sites (`render @post`, `render post`, `render @posts`), not just explicit `render "posts/post"` calls.
+- **`rails_get_controllers`** and **`rails_analyze_feature`** no longer list an inherited `before_action` twice (once as inherited, once from the reflection-derived full chain).
+- **`rails_runtime_info`** "Table Sizes" lists real application tables instead of SQLite internal objects (`sqlite_schema`, `sqlite_autoindex_*`, `sqlite_sequence`) and index b-trees that were crowding out the app tables.
+- **`rails_get_gems`** strips the platform suffix from versions (`sqlite3 2.9.5`, not `sqlite3 2.9.5-x86_64-linux-musl`) on multi-platform lockfiles.
+- **`rails_get_test_info`** falls back to `Gemfile.lock` to report the test framework (minitest/rspec) when no `test/` or `spec/` directory exists yet, instead of "unknown".
+- **`rails_get_frontend_stack`** no longer renders a literal `[]` for empty state-management data.
+- **`rails_onboard`** reports the app route count instead of pairing the framework-inclusive total with the app-controller count ("14 app routes across 3 controllers", not "46 routes across 3 controllers").
+- **MCP resources** return a proper `-32602 Resource not found: <uri>` for unknown URIs and blocked paths instead of a generic "Internal error" with the URI stripped (on `mcp >= 0.20`; older mcp keeps prior behavior). Path traversal and sensitive-file access remain blocked.
+- **CLI `--json`** flag is honored in any position (`tool NAME args --json`), not only before the tool name.
+- **CLI presets** (`architecture`, `debugging`, `migration`) now chain tools that produce useful output with zero arguments, instead of calling tools whose required arguments were never supplied.
+- **Standalone/zero-config CLI on Ruby 3.4+** no longer crashes with `Gem::LoadError: already activated psych 5.4.0, but your Gemfile requires psych 5.3.1` (or the equivalent for `date`). The standalone executable pre-activates Ruby 3.4's newer default-gem versions before the app's `Bundler.setup` runs; it now clears those pre-activated specs first so Bundler activates the versions the app resolves. No-op under `bundle exec` (in-Gemfile mode is unaffected).
+
 ## [5.11.2] - 2026-06-16
 
 ### Fixed

data/exe/rails-ai-context

@@ -41,7 +41,15 @@ class RailsAiContextCLI < Thor
         return
       end
 
-      runner = ::RailsAiContext::CLI::ToolRunner.new(name, args, json_mode: options[:json])
+      # `--json` is consumed as the Thor option only when it precedes the tool
+      # name; `stop_on_unknown_option! :tool` passes it through into `args` when
+      # it follows the name (the natural CLI position). Honor both placements by
+      # also stripping it from args here, mirroring the --help handling above.
+      json_mode = options[:json]
+      json_mode = true if args.delete("--json")
+      json_mode = true if args.delete("-j")
+
+      runner = ::RailsAiContext::CLI::ToolRunner.new(name, args, json_mode: json_mode)
       puts runner.run
     rescue SystemExit
       raise # let exit() propagate (from boot_rails!)
@@ -190,29 +198,34 @@ class RailsAiContextCLI < Thor
 
     desc "preset NAME", "Run a multi-tool preset (architecture, debugging, migration)"
     def preset(name = nil)
+      # Each preset chains tools that produce useful output with ZERO
+      # user-supplied arguments. Tools that require a target (analyze_feature
+      # needs a feature, migration_advisor needs an action+table, validate needs
+      # file paths) are deliberately excluded - in a no-arg preset they only
+      # emit "please provide X" prompts.
       presets = {
         "architecture" => {
-          desc: "Full feature analysis across all layers",
+          desc: "Architecture overview across all layers",
           tools: [
-            { name: "analyze_feature", params: {} },
+            { name: "onboard", params: {} },
             { name: "dependency_graph", params: {} },
             { name: "performance_check", params: {} }
           ]
         },
         "debugging" => {
-          desc: "Diagnose recent issues and validate current state",
+          desc: "Diagnose recent issues and inspect live state",
           tools: [
             { name: "read_logs", params: { level: "ERROR", lines: 100 } },
             { name: "review_changes", params: {} },
-            { name: "validate", params: {} }
+            { name: "runtime_info", params: {} }
           ]
         },
         "migration" => {
-          desc: "Schema overview with migration advice and validation",
+          desc: "Schema overview with migration status and index advice",
           tools: [
             { name: "get_schema", params: { detail: "summary" } },
-            { name: "migration_advisor", params: { action: "status" } },
-            { name: "validate", params: {} }
+            { name: "runtime_info", params: { section: "database" } },
+            { name: "performance_check", params: { category: "indexes" } }
           ]
         }
       }
@@ -577,6 +590,16 @@ class RailsAiContextCLI < Thor
       # captured specs already exist in Gem.loaded_specs and our `||=` skips them).
       pre_boot_specs = capture_standalone_specs
 
+      # Standalone mode on Ruby 3.4+: this CLI process lazily activates the
+      # newest/default version of stdlib gems (e.g. psych via `require "yaml"`,
+      # date via transitive requires) BEFORE the app's Bundler.setup runs inside
+      # `require config_path`. If the app resolves a different version, Bundler
+      # raises `Gem::LoadError: already activated psych 5.4.0, but your Gemfile
+      # requires psych 5.3.1`. Clear the pre-activated specs so Bundler activates
+      # the versions the app resolves. No-op under `bundle exec`, so in-Gemfile
+      # mode is unaffected.
+      drop_conflicting_gem_activations!
+
       require config_path
 
       # Restore paths and specs that Bundler.setup stripped (standalone mode).
@@ -615,6 +638,31 @@ class RailsAiContextCLI < Thor
         next
       end
     end
+
+    # Remove activated gem specs whose version differs from the app's
+    # Gemfile.lock pin, so the app's Bundler.setup can activate the locked
+    # version instead of raising `Gem::LoadError: already activated`. Only the
+    # in-memory spec registration is removed; already-loaded stdlib code stays,
+    # which is safe (require is idempotent and the affected gems - psych, date,
+    # bigdecimal, stringio - keep stable APIs across the involved versions).
+    # No-op under `bundle exec` (BUNDLE_BIN_PATH set): Bundler already governs
+    # activation there, so in-Gemfile mode is untouched.
+    def drop_conflicting_gem_activations!
+      return if ENV["BUNDLE_BIN_PATH"]
+      return unless defined?(Gem) && Gem.respond_to?(:loaded_specs)
+
+      # Drop every pre-activated spec except bundler (which is mid-execution),
+      # so the app's Bundler.setup activates each gem at the version IT resolves
+      # rather than colliding with whatever RubyGems pre-activated. Without this,
+      # `require config_path` raises `Gem::LoadError: already activated psych
+      # 5.4.0, but your Gemfile requires psych 5.3.1`. Only the in-memory spec
+      # registration is removed; already-loaded code stays (require is
+      # idempotent). The gem's own spec and its MCP deps are captured before
+      # this call and restored after boot (see capture_standalone_specs).
+      Gem.loaded_specs.delete_if { |name, _| name != "bundler" }
+    rescue => e
+      $stderr.puts "[rails-ai-context] drop_conflicting_gem_activations! failed: #{e.message}" if ENV["DEBUG"]
+    end
 end
 
 RailsAiContextCLI.start(ARGV)

data/lib/rails_ai_context/introspectors/gem_introspector.rb

@@ -221,7 +221,13 @@ module RailsAiContext
           end
 
           if in_gems && (match = line.match(/^\s{4}(\S+)\s+\((.+)\)/))
-            gems[match[1]] = match[2]
+            # Bundler writes platform-specific gems as "name (1.2.3-x86_64-linux-musl)",
+            # listing one line per platform in a multi-platform lockfile. Last-write-wins
+            # would otherwise surface an arbitrary, often wrong, platform suffix (e.g.
+            # x86_64-linux-musl on an arm64-darwin machine). RubyGems versions never
+            # contain a hyphen, so the text before the first "-" is the clean version;
+            # the platform tail is an install detail, not useful AI context.
+            gems[match[1]] = match[2].split("-", 2).first
           end
         end
 

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -52,7 +52,25 @@ module RailsAiContext
       private
 
       def active_record_connected?
-        defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+        return false unless defined?(ActiveRecord::Base)
+
+        # ActiveRecord::Base.connected? only reports whether a connection has
+        # ALREADY been checked out on this thread. On a freshly booted MCP
+        # server - before any query runs - it is false even when the database
+        # is fully reachable, which wrongly forces the static schema.rb parse.
+        # That parse omits the implicit `id` primary key and reports
+        # schema.rb-approximate types instead of the live column metadata,
+        # undercutting the gem's "live, zero stale data" promise.
+        return true if ActiveRecord::Base.connected?
+
+        # Force a real connection. In Rails 8 a lazily checked-out connection
+        # reports active? => nil until it actually materializes, so a trivial
+        # query is the reliable reachability probe. The rescue below falls back
+        # to static parsing when the database is genuinely unreachable (no DB
+        # configured, db:create not run, server down). SELECT 1 is valid on
+        # sqlite3, postgresql, mysql2, and trilogy.
+        ActiveRecord::Base.connection.select_value("SELECT 1")
+        true
       rescue => e
         $stderr.puts "[rails-ai-context] active_record_connected? failed: #{e.message}" if ENV["DEBUG"]
         false

data/lib/rails_ai_context/introspectors/test_introspector.rb

@@ -46,10 +46,33 @@ module RailsAiContext
         elsif Dir.exist?(File.join(root, "test"))
           "minitest"
         else
-          "unknown"
+          # No test/spec directory yet (e.g. an app scaffolded with --skip-test,
+          # or before the first test is written). The framework is still
+          # knowable from the bundle: rspec-rails means RSpec, otherwise a Rails
+          # app uses its bundled minitest default. Reporting "unknown" here
+          # contradicts gems/generate_test, which both already resolve it.
+          detect_framework_from_lockfile || "unknown"
         end
       end
 
+      # Resolve the test framework from Gemfile.lock when no test directory
+      # exists. rspec-rails wins (it replaces the convention); otherwise
+      # minitest, which ships with every Rails app. Returns nil when there is
+      # no lockfile or no recognizable test gem.
+      def detect_framework_from_lockfile
+        lock_path = File.join(root, "Gemfile.lock")
+        return nil unless File.exist?(lock_path)
+
+        content = RailsAiContext::SafeFile.read(lock_path) || ""
+        return "rspec" if content.match?(/^\s{4}rspec-rails\s/)
+        return "minitest" if content.match?(/^\s{4}minitest\s/)
+
+        nil
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_framework_from_lockfile failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
       def detect_factories
         dirs = [
           File.join(root, "spec/factories"),

data/lib/rails_ai_context/resources.rb

@@ -121,6 +121,19 @@ module RailsAiContext
 
         server.resources_read_handler do |params|
           handle_read(params)
+        rescue RailsAiContext::Error => e
+          # handle_read / VFS raise RailsAiContext::Error for unknown URIs and
+          # blocked paths (traversal, sensitive files). Left unhandled, the MCP
+          # SDK collapses them into a generic "-32603 Internal error" that hides
+          # the URI. On mcp >= 0.20 re-raise as the SDK's ResourceNotFoundError
+          # so the client gets a proper "-32602 Resource not found: <uri>" with
+          # the URI in error data (the uniform message also avoids leaking why a
+          # blocked path was rejected). That class doesn't exist on older but
+          # still-supported mcp (gemspec allows >= 0.8), so fall back to the
+          # original error there - same behavior as before this wrapper.
+          raise e unless defined?(MCP::Server::ResourceNotFoundError)
+
+          raise MCP::Server::ResourceNotFoundError.new(params[:uri])
         end
       end
 

data/lib/rails_ai_context/tools/analyze_feature.rb

@@ -159,7 +159,11 @@ module RailsAiContext
                 lines << "- **Inherited filters:** #{parent_filters.map { |f| "#{f[:name]} _(from #{info[:parent_class]})_" }.join(', ')}"
               end
 
-              filters = (info[:filters] || []).select { |f| f.is_a?(Hash) }.map do |f|
+              # `info[:filters]` is reflection-derived and already includes the
+              # inherited chain, so drop the ones already shown on the Inherited
+              # line to avoid listing them twice (e.g. set_current_user).
+              parent_names = parent_filters.map { |f| f[:name] }.to_set
+              filters = (info[:filters] || []).select { |f| f.is_a?(Hash) && !parent_names.include?(f[:name]) }.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?

data/lib/rails_ai_context/tools/diagnose.rb

@@ -194,9 +194,42 @@ module RailsAiContext
             result[:method_name] = m[1]
           end
 
+          # When the error is a bare message with no "ClassName:" prefix - e.g. a
+          # line copied from a browser error page, or Ruby 3.4+'s
+          # "undefined method 'x' for an instance of Y" phrasing that drops the
+          # trailing "(NoMethodError)" - infer the class from the message
+          # signature. classify_error matches on "exception_class message", so a
+          # recovered class name resolves both the header and the classification.
+          result[:exception_class] ||= infer_exception_class(result[:message])
+
           result
         end
 
+        # Map a raw error message (no class prefix) to its Ruby/Rails exception
+        # class by signature. Returns nil when nothing matches so the caller
+        # keeps the "Unknown" fallback. Order matters: the NameError
+        # "undefined local variable or method" phrasing is checked before the
+        # NoMethodError "undefined method" phrasing it shares a prefix with.
+        EXCEPTION_SIGNATURES = [
+          [ /undefined local variable or method\b/, "NameError" ],
+          [ /uninitialized constant\b/, "NameError" ],
+          [ /undefined method\b/, "NoMethodError" ],
+          [ /wrong number of arguments|missing keywords?:|unknown keywords?:/, "ArgumentError" ],
+          [ /couldn't find .+ with/i, "ActiveRecord::RecordNotFound" ],
+          [ /param is missing or the value is empty/i, "ActionController::ParameterMissing" ],
+          [ /no route matches/i, "ActionController::RoutingError" ],
+          [ /no such column|no such table|relation ".+" does not exist|column .+ does not exist/i, "ActiveRecord::StatementInvalid" ]
+        ].freeze
+
+        def infer_exception_class(message)
+          return nil if message.nil? || message.empty?
+
+          EXCEPTION_SIGNATURES.each do |pattern, klass|
+            return klass if message.match?(pattern)
+          end
+          nil
+        end
+
         def classify_error(parsed)
           error_str = "#{parsed[:exception_class]} #{parsed[:message]}"
 

data/lib/rails_ai_context/tools/get_controllers.rb

@@ -204,11 +204,17 @@ module RailsAiContext
 
         if parent_filters.any? || filters.any? || skipped_filters.any?
           lines << "" << "## Applicable Filters"
-          parent_filters.each do |f|
+          # Dedupe parent vs own filters by name - `filters` is reflection-derived
+          # for loaded controllers and already includes the inherited chain, so
+          # listing parent_filters separately would double-list them.
+          applicable_names = filters.map { |f| f[:name] }.to_set
+          parent_names = parent_filters.map { |f| f[:name] }.to_set
+          parent_filters.reject { |f| applicable_names.include?(f[:name]) }.each do |f|
             lines << "- `#{f[:kind]}` **#{f[:name]}** _(from #{info[:parent_class]})_"
           end
           filters.each do |f|
             line = "- `#{f[:kind]}` **#{f[:name]}**"
+            line += " _(from #{info[:parent_class]})_" if parent_names.include?(f[:name])
             line += " (only: #{f[:only].join(', ')})" if f[:only]&.any?
             lines << line
           end
@@ -484,16 +490,26 @@ module RailsAiContext
           lines << info[:actions].map { |a| "- `#{a}`" }.join("\n")
         end
 
-        # Show full filter chain including inherited from parent controller
+        # Show full filter chain including inherited from parent controller.
+        # `all_filters` is reflection-derived for loaded controllers and already
+        # includes the inherited chain; `parent_filters` re-parses the parent
+        # source. Listing both verbatim double-lists inherited filters (e.g.
+        # set_current_user appearing twice), so dedupe by name: surface only the
+        # parent filters missing from the own list (covers source-only
+        # controllers whose own list lacks the chain), then annotate the
+        # inherited entries in the own list rather than repeating them.
         all_filters = info[:filters] || []
         parent_filters = detect_parent_filters(info[:parent_class])
         if parent_filters.any? || all_filters.any?
           lines << "" << "## Filters"
-          parent_filters.each do |f|
+          all_names = all_filters.map { |f| f[:name] }.to_set
+          parent_names = parent_filters.map { |f| f[:name] }.to_set
+          parent_filters.reject { |f| all_names.include?(f[:name]) }.each do |f|
             lines << "- `#{f[:kind]}` **#{f[:name]}** _(from #{info[:parent_class]})_"
           end
           all_filters.each do |f|
             detail = "- `#{f[:kind]}` **#{f[:name]}**"
+            detail += " _(from #{info[:parent_class]})_" if parent_names.include?(f[:name])
             detail += " (only: #{f[:only].join(', ')})" if f[:only]&.any?
             lines << detail
           end

data/lib/rails_ai_context/tools/get_frontend_stack.rb

@@ -110,7 +110,12 @@ module RailsAiContext
           lines << "- **Framework:** #{data[:framework]}#{version_suffix(data[:version])}" if data[:framework]
           lines << "- **Mounting strategy:** #{data[:mounting_strategy]}" if data[:mounting_strategy]
           lines << "- **Build tool:** #{data[:build_tool]}" if data[:build_tool]
-          lines << "- **State management:** #{data[:state_management]}" if data[:state_management]
+          # state_management is an array for JS-framework apps and a string for
+          # others; an empty array is truthy in Ruby, so guard on presence and
+          # join arrays to avoid rendering a literal "[]".
+          state_management = data[:state_management]
+          state_management = state_management.join(", ") if state_management.is_a?(Array)
+          lines << "- **State management:** #{state_management}" if state_management.present?
           lines << "- **Package manager:** #{data[:package_manager]}" if data[:package_manager]
 
           # TypeScript

data/lib/rails_ai_context/tools/get_partial_interface.rb

@@ -377,6 +377,21 @@ module RailsAiContext
           basename                                                  # status_badge
         ].uniq
 
+        # Implicit object/collection rendering resolves to this partial via
+        # to_partial_path: `render @post`, `render post`, `render @posts`,
+        # `render posts` all hit posts/_post. These are extremely common and
+        # carry no quoted partial name, so the explicit-string match above
+        # misses them. Only treat the partial as a conventional resource
+        # partial (posts/_post) when its directory is the pluralized basename
+        # or it is top-level, to avoid matching unrelated variables.
+        plural = basename.pluralize
+        implicit_names =
+          if dir_prefix.empty? || dir_prefix.split("/").last == plural
+            [ basename, plural ].uniq
+          else
+            []
+          end
+
         view_files = Dir.glob(File.join(views_dir, "**", "*.{erb,haml,slim}")).sort
 
         view_files.each do |file|
@@ -387,6 +402,7 @@ module RailsAiContext
           relative = file.sub("#{root}/", "")
 
           content.each_line.with_index(1) do |line, line_num|
+            matched_line = false
             search_patterns.each do |search_name|
               # Match render "partial_name" or render partial: "partial_name"
               # Allow content before search_name (e.g. "shared/status_badge" matches "status_badge")
@@ -407,8 +423,27 @@ module RailsAiContext
                 locals: locals_passed,
                 snippet: line.strip
               }
+              matched_line = true
               break # one match per line is enough
             end
+
+            next if matched_line
+
+            # Implicit object/collection render: `render @post`, `render post`,
+            # `render @posts`. The variable is a bareword or ivar (no quotes),
+            # and \b guards against prefixes like post_path / posts_controller.
+            implicit_names.each do |var|
+              next unless line.match?(/render\s+@?#{Regexp.escape(var)}\b/)
+              next if line.match?(/render\s.*["']/) # a quoted render is explicit, handled above
+
+              sites << {
+                file: relative,
+                line: line_num,
+                locals: [],
+                snippet: line.strip
+              }
+              break
+            end
           end
         end
 

data/lib/rails_ai_context/tools/get_turbo_map.rb

@@ -106,10 +106,13 @@ module RailsAiContext
       private_class_method def self.format_summary(model_broadcasts, rb_broadcasts, view_subscriptions, view_frames, warnings, filter_label: nil)
         total_broadcasts = model_broadcasts.size + rb_broadcasts.size
         turbo_data = cached_context[:turbo]
-        turbo_stream_response_count = turbo_data.is_a?(Hash) && !turbo_data[:error] ? turbo_data[:turbo_stream_responses]&.size.to_i : 0
+        turbo_usable = turbo_data.is_a?(Hash) && !turbo_data[:error]
+        turbo_stream_response_count = turbo_usable ? turbo_data[:turbo_stream_responses]&.size.to_i : 0
+        turbo_stream_template_count = turbo_usable ? turbo_data[:turbo_streams]&.size.to_i : 0
 
         lines = [ "# Turbo Map", "" ]
-        lines << "- **Turbo Stream responses:** #{turbo_stream_response_count} (controller `.turbo_stream.erb` templates)" if turbo_stream_response_count > 0
+        lines << "- **Turbo Stream responses:** #{turbo_stream_response_count} (controllers responding with `turbo_stream` format)" if turbo_stream_response_count > 0
+        lines << "- **Turbo Stream templates:** #{turbo_stream_template_count} (`.turbo_stream.erb` view templates)" if turbo_stream_template_count > 0
         lines << "- **Model broadcasts:** #{model_broadcasts.size} (via `broadcasts`, `broadcasts_to`, etc.)"
         lines << "- **Explicit broadcasts:** #{rb_broadcasts.size} (via `broadcast_*_to` calls in .rb files)"
         lines << "- **Stream subscriptions:** #{view_subscriptions.size} (`turbo_stream_from` in views)"
@@ -151,6 +154,18 @@ module RailsAiContext
             end
             lines << ""
           end
+
+          # .turbo_stream.erb response templates - the most common scaffold-style
+          # Turbo Stream pattern. The introspector collects these via its view
+          # scan; without rendering them here, an app whose streams are driven
+          # entirely by templates wrongly reports "no Turbo Streams detected".
+          if turbo_data[:turbo_streams]&.any?
+            actions = turbo_data[:stream_actions]
+            action_summary = actions.is_a?(Hash) && actions.any? ? " (actions: #{actions.map { |a, n| "#{a}×#{n}" }.join(', ')})" : ""
+            lines << "## Turbo Stream Templates (#{turbo_data[:turbo_streams].size})#{action_summary}"
+            turbo_data[:turbo_streams].first(20).each { |tpl| lines << "- `#{tpl}`" }
+            lines << ""
+          end
         end
 
         # Model broadcasts
@@ -200,8 +215,9 @@ module RailsAiContext
         end
 
         has_turbo_stream_responses = turbo_data.is_a?(Hash) && turbo_data[:turbo_stream_responses]&.any?
+        has_stream_templates = turbo_data.is_a?(Hash) && turbo_data[:turbo_streams]&.any?
 
-        if model_broadcasts.empty? && rb_broadcasts.empty? && view_subscriptions.empty? && view_frames.empty? && !has_turbo_stream_responses
+        if model_broadcasts.empty? && rb_broadcasts.empty? && view_subscriptions.empty? && view_frames.empty? && !has_turbo_stream_responses && !has_stream_templates
           if filter_label
             lines << "_No Turbo usage matching #{filter_label}. Try without filter to see all Turbo Streams and Frames._"
           else
@@ -240,6 +256,15 @@ module RailsAiContext
             end
             lines << ""
           end
+
+          # .turbo_stream.erb response templates (scaffold-style Turbo Streams).
+          if turbo_data[:turbo_streams]&.any?
+            lines << "## Turbo Stream Templates (#{turbo_data[:turbo_streams].size})"
+            turbo_data[:turbo_streams].each { |tpl| lines << "- `#{tpl}`" }
+            actions = turbo_data[:stream_actions]
+            lines << "- **Actions used:** #{actions.map { |a, n| "#{a}×#{n}" }.join(', ')}" if actions.is_a?(Hash) && actions.any?
+            lines << ""
+          end
         end
 
         # Model broadcasts with full context
@@ -321,8 +346,9 @@ module RailsAiContext
         end
 
         has_turbo_stream_responses = turbo_data.is_a?(Hash) && turbo_data[:turbo_stream_responses]&.any?
+        has_stream_templates = turbo_data.is_a?(Hash) && turbo_data[:turbo_streams]&.any?
 
-        if model_broadcasts.empty? && rb_broadcasts.empty? && view_subscriptions.empty? && view_frames.empty? && !has_turbo_stream_responses
+        if model_broadcasts.empty? && rb_broadcasts.empty? && view_subscriptions.empty? && view_frames.empty? && !has_turbo_stream_responses && !has_stream_templates
           if filter_label
             lines << "_No Turbo usage matching #{filter_label}. Try without filter to see all Turbo Streams and Frames._"
           else

data/lib/rails_ai_context/tools/get_view.rb

@@ -268,10 +268,22 @@ module RailsAiContext
         full_path = views_dir.join(path)
 
         unless File.exist?(full_path)
-          dir = File.dirname(path)
-          siblings = Dir.glob(File.join(views_dir, dir, "*")).map { |f| "#{dir}/#{File.basename(f)}" }.sort.first(10)
-          hint = siblings.any? ? " Files in #{dir}/: #{siblings.join(', ')}" : ""
-          return text_response("View not found: #{path}.#{hint}")
+          # Agents (and this tool's own description) naturally address a view by
+          # its logical "controller/action" path with no extension, e.g.
+          # "posts/index". Resolve that to the concrete template
+          # ("posts/index.html.erb") before giving up. Only attempts resolution
+          # for safe, extension-less path shapes so the glob can't be abused;
+          # the resolved path still runs the realpath/sensitive/size checks below.
+          resolved = resolve_template_path(path, views_dir)
+          if resolved
+            path = resolved
+            full_path = views_dir.join(path)
+          else
+            dir = File.dirname(path)
+            siblings = Dir.glob(File.join(views_dir, dir, "*")).map { |f| "#{dir}/#{File.basename(f)}" }.sort.first(10)
+            hint = siblings.any? ? " Files in #{dir}/: #{siblings.join(', ')}" : ""
+            return text_response("View not found: #{path}.#{hint}")
+          end
         end
         # Containment check with separator + post-realpath sensitive recheck.
         # Mirrors the v5.8.1 fix in vfs.rb / get_edit_context.rb. Without
@@ -304,6 +316,26 @@ module RailsAiContext
         text_response("# #{path}\n\n```erb\n#{content}\n```")
       end
 
+      # Resolve a logical, extension-less view path ("posts/index") to a
+      # concrete template relative path ("posts/index.html.erb"). Returns nil
+      # when the path already carries an extension, contains glob-unsafe
+      # characters, or matches no template - so the caller falls back to its
+      # not-found hint. Prefers an .html.* format when several exist (the page
+      # an agent almost always means), otherwise the first match alphabetically.
+      private_class_method def self.resolve_template_path(path, views_dir)
+        # Restrict to safe "segment/segment" shapes with no extension so the
+        # Dir.glob below stays literal (no *, ?, [] or dot to expand).
+        return nil unless path.match?(%r{\A[\w\-]+(?:/[\w\-]+)*\z})
+
+        matches = Dir.glob(File.join(views_dir, "#{path}.*"))
+          .reject { |f| File.directory?(f) }
+          .map { |f| f.sub("#{views_dir}/", "") }
+          .sort
+        return nil if matches.empty?
+
+        matches.find { |m| m.include?(".html.") || m.end_with?(".html") } || matches.first
+      end
+
       # Strip inline SVG blocks - they're visual noise that buries the signal AI needs.
       # Replaces <svg ...>...</svg> with a compact placeholder.
       private_class_method def self.strip_svg(content)

data/lib/rails_ai_context/tools/onboard.rb

@@ -261,7 +261,14 @@ module RailsAiContext
           end
 
           lines << ""
-          lines << "Total: #{routes[:total_routes]} routes across #{app_ctrls.size} controllers."
+          # total_routes counts every route incl. framework engines (action_mailbox,
+          # active_storage, etc.), so pairing it with the app-controller count
+          # misrepresents the app (e.g. "46 routes across 3 controllers"). Report
+          # the app route count and note the framework total separately.
+          app_route_count = app_ctrls.values.sum { |route_list| route_list.size }
+          total = routes[:total_routes].to_i
+          framework_note = total > app_route_count ? " (#{total} total including framework routes)" : ""
+          lines << "Total: #{app_route_count} app routes across #{app_ctrls.size} controllers#{framework_note}."
           lines << ""
           lines
         end

data/lib/rails_ai_context/tools/runtime_info.rb

@@ -135,37 +135,58 @@ module RailsAiContext
           [ "## Database", "", "_Not available: #{e.message}_", "" ]
         end
 
+        # Rails-managed bookkeeping tables - real tables, but noise in a
+        # "table sizes" view aimed at application data (matches the schema
+        # introspector, which also skips them).
+        INTERNAL_TABLES = %w[schema_migrations ar_internal_metadata].freeze
+
         def gather_table_sizes(conn, adapter)
-          case adapter
-          when /postgresql/
-            sql = "SELECT relname AS name, pg_total_relation_size(relid) AS bytes FROM pg_stat_user_tables ORDER BY bytes DESC"
-            conn.select_all(sql).map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
-          when /mysql/
-            sql = "SELECT table_name AS name, (data_length + index_length) AS bytes FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = DATABASE() ORDER BY bytes DESC"
-            conn.select_all(sql).map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
-          when /sqlite/
-            # Try dbstat virtual table first, fall back to whole-DB size
-            begin
-              result = conn.select_all("SELECT name, SUM(pgsize) AS bytes FROM dbstat GROUP BY name ORDER BY bytes DESC")
-              return result.map { |r| { name: r["name"], bytes: r["bytes"].to_i } } if result.any?
-            rescue => e
-              $stderr.puts "[rails-ai-context] gather_table_sizes failed: #{e.message}" if ENV["DEBUG"]
-              nil
+          rows =
+            case adapter
+            when /postgresql/
+              sql = "SELECT relname AS name, pg_total_relation_size(relid) AS bytes FROM pg_stat_user_tables ORDER BY bytes DESC"
+              conn.select_all(sql).map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
+            when /mysql/
+              sql = "SELECT table_name AS name, (data_length + index_length) AS bytes FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = DATABASE() ORDER BY bytes DESC"
+              conn.select_all(sql).map { |r| { name: r["name"], bytes: r["bytes"].to_i } }
+            when /sqlite/
+              gather_sqlite_table_sizes(conn)
             end
-            # Fallback: whole database size
-            page_count = conn.select_value("PRAGMA page_count").to_i
-            page_size = conn.select_value("PRAGMA page_size").to_i
-            total = page_count * page_size
-            tables = conn.select_values("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
-            tables.map { |t| { name: t, bytes: total / [ tables.size, 1 ].max } }
-          else
-            nil
-          end
+          return nil unless rows
+
+          rows.reject { |r| INTERNAL_TABLES.include?(r[:name]) }
         rescue => e
           $stderr.puts "[rails-ai-context] gather_table_sizes failed: #{e.message}" if ENV["DEBUG"]
           nil
         end
 
+        def gather_sqlite_table_sizes(conn)
+          # dbstat lists every b-tree: user tables, their indexes, and SQLite
+          # internals (sqlite_schema, sqlite_autoindex_*, sqlite_sequence).
+          # Restrict to real application tables so indexes and internal objects
+          # don't crowd out (or get mistaken for) the tables agents care about.
+          app_tables = conn.select_values(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+          ).to_set
+
+          begin
+            result = conn.select_all("SELECT name, SUM(pgsize) AS bytes FROM dbstat GROUP BY name ORDER BY bytes DESC")
+            rows = result.filter_map do |r|
+              { name: r["name"], bytes: r["bytes"].to_i } if app_tables.include?(r["name"])
+            end
+            return rows if rows.any?
+          rescue => e
+            $stderr.puts "[rails-ai-context] gather_sqlite_table_sizes (dbstat) failed: #{e.message}" if ENV["DEBUG"]
+          end
+
+          # Fallback: whole-DB size split across user tables (dbstat unavailable).
+          page_count = conn.select_value("PRAGMA page_count").to_i
+          page_size = conn.select_value("PRAGMA page_size").to_i
+          total = page_count * page_size
+          tables = app_tables.to_a.sort
+          tables.map { |t| { name: t, bytes: total / [ tables.size, 1 ].max } }
+        end
+
         def gather_pending_migrations
           migrate_dir = File.join(Rails.root, "db/migrate")
           return nil unless Dir.exist?(migrate_dir)

data/lib/rails_ai_context/version.rb

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

data/server.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.10.0",
+  "version": "5.12.0",
   "packages": [
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.10.0/rails-ai-context-mcp.mcpb",
+      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.12.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.11.2
+  version: 5.12.0
 platform: ruby
 authors:
 - crisnahine