rails-ai-context 5.20.3 → 5.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 812fc2b5160e39c746e9d399bf6cea5752339f53c57a80f3ce0d01a5e819b7d0
-  data.tar.gz: 22254f62db474a0f0b7f364f156b3098819b52285e88df2835b32ea25c86972b
+  metadata.gz: e2ccd7eb081bc5f6f34e998978e38d7d9d5282d097818224c10bd56ff4d30c75
+  data.tar.gz: 0bb8a8ad8f57a11a04a41dd2ab9e30f57f25b08382d1b5edca67af0c3db68f38
 SHA512:
-  metadata.gz: 4eddc9f145293be65bc99e9b0dd5334de7570ef217df4dca4f554c191ae314bd6544ed16f49be013a2db93c3394e49f02204c1d76c1c256d7394881ea273eb81
-  data.tar.gz: 53e469b48920a4baefe955ff90624199f60200a6759d180a02d040d4c1368322d0b9648637fe4a13d20cf1ecc9153d3b7a1b041e1d41ae835c7a8e523cfd4bdf
+  metadata.gz: dadae053988700c4c82e841dc5d18c0c22f6584ceef3616e7a520388e57bea89bb1535dc2ca658b5960d3d5d3a11ecbedc912f69386485412c0d833d1c8d1cfa
+  data.tar.gz: 07bba392bb191112f18cf14e89147b445078d04b404d0bea9f974e148f42f1ef2ee4d83ccacc7049e132dacf2ad0c1ac17fd4079b779d2dd0d6039c739359092

data/CHANGELOG.md

@@ -5,6 +5,71 @@ 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.21.0] - 2026-08-12
+
+### Fixed
+
+- **`get_env` no longer offers a name the app never reads.** An app that builds
+  its variable names by interpolation, the normal shape when it carries several
+  Redis connections, had `#{prefix}URL` reported as a variable name and
+  `defaults[:port]` reported as that variable's default. The scan reads the
+  parser now instead of matching whatever sat between two quotes, so a name
+  that does not exist until runtime is not offered to someone writing a
+  `.env.example`, and a default is printed only when it is a value. Comments
+  drop out for free, including one trailing a line that also reads `ENV`.
+  (#129)
+
+- **`get_controllers` no longer lists `set_locale` as an action.** A controller
+  whose own file defines no public method fell back to `action_methods`, which
+  subtracts inherited methods only as far as the nearest abstract ancestor:
+  everything `ApplicationController` and its concerns define publicly came back
+  as an action, so a two-route controller reported 19 of them. The actions of a
+  thin subclass now come from the source of the ancestor that defines them.
+  Reflection is left for the case that has no source to read, an ancestor this
+  app does not own the file for, which is what a controller inheriting from a
+  gem or an engine looks like. (#130)
+
+- **`get_service_pattern` reports the service's entry point, not a nested
+  class's.** Nesting a query builder inside the service that uses it is a
+  normal way to organise a large one, and the line scan could not see it: it
+  named `QueryBuilder#build` as the entry point of a 312-line service, and a
+  `private` inside a nested class hid the real `call` that followed the nested
+  class's `end`, reporting the service as having no entry point at all. The
+  methods now come from the AST, scoped to the class the file is named for.
+  (#131)
+
+- **`get_test_info` counts tests, not files.** "Test Counts by Category"
+  globbed every `.rb` under a category directory, so four mailer specs sitting
+  beside four mailer previews counted as eight tests. Anything a project keeps
+  next to its specs inflated the number. (#132)
+
+- **`get_concern` finds every concern the app has.** It searched two hardcoded
+  directories while `get_active_support` searched five, so one run answered 80
+  concerns and 81 concerns for the same app, and the mailer concern only the
+  second one found could not be reached by name through the first. Both now
+  read one seam, which discovers `app/*/concerns` the way Rails autoloads it,
+  so an app that keeps `app/serializers/concerns` is covered too. Concerns are
+  grouped and filterable by the directory that owns them. (#133)
+
+- **Namespaced Pundit policies keep their namespace.** Policy names came from
+  the basename, so `app/policies/admin/collection_policy.rb` and
+  `app/policies/collection_policy.rb` both read as `CollectionPolicy`. One name
+  was listed twice and the other class appeared nowhere in the generated
+  context or in `CLAUDE.md`, including the one that defines `destroy?`. (#135)
+
+- **Re-running a release no longer fails on the MCP Registry.** The registry
+  answers a repeat version with a 400, and the publish step had no guard, so
+  re-running a release that had already succeeded turned the workflow red with
+  nothing wrong. It now checks for the version first, the way the RubyGems step
+  already did.
+
+### Changed
+
+- **`config.concern_paths` replaces concern discovery instead of adding to
+  it.** Left unset, which is now the default, every `app/*/concerns` directory
+  is discovered. Setting it means those directories and no others, so it can
+  narrow as well as reach outside `app/`.
+
 ## [5.20.3] - 2026-08-11
 
 ### Fixed

data/docs/CONFIGURATION.md

@@ -114,7 +114,7 @@ preset: full
 | `max_search_results` | Integer | `200` | Maximum search results |
 | `max_validate_files` | Integer | `50` | Maximum files for validation |
 | `search_extensions` | Array | `["rb", "js", "erb", "yml", "yaml", "json", "ts", "tsx", "vue", "svelte", "haml", "slim"]` | File extensions to search |
-| `concern_paths` | Array | `["app/models/concerns", "app/controllers/concerns"]` | Paths to scan for concerns |
+| `concern_paths` | Array | `nil` (discovers `app/*/concerns`) | Paths to scan for concerns. Setting it replaces discovery, so it can narrow as well as widen |
 | `frontend_paths` | Array | `nil` (auto-detect) | Override frontend file paths |
 | `extra_app_paths` | Array | `[]` | Extra directories under the app root to treat as application code |
 

data/docs/GUIDE.md

@@ -1285,8 +1285,10 @@ if defined?(RailsAiContext)
     # File extensions for Ruby fallback search
     # config.search_extensions = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
 
-    # Where to look for concern source files
-    # config.concern_paths = %w[app/models/concerns app/controllers/concerns]
+    # Where to look for concern source files. Left unset, every
+    # app/*/concerns directory is discovered. Setting this replaces
+    # that list, so it can narrow as well as reach outside app/.
+    # config.concern_paths = %w[app/models/concerns lib/concerns]
 
     # --- Live reload ---
 
@@ -1352,7 +1354,7 @@ end
 | `excluded_filters` | Array | `verify_authenticity_token`, etc. | Framework filter names hidden from controller output |
 | `excluded_middleware` | Array | standard Rails middleware | Default middleware hidden from config output |
 | `search_extensions` | Array | `rb js erb yml yaml json ts tsx vue svelte haml slim` | File extensions for Ruby fallback search |
-| `concern_paths` | Array | `app/models/concerns app/controllers/concerns` | Where to look for concern source files |
+| `concern_paths` | Array | `nil` (discovers `app/*/concerns`) | Where to look for concern source files. Setting it replaces discovery |
 
 ### Root file generation
 

data/lib/generators/rails_ai_context/install/install_generator.rb

@@ -311,8 +311,10 @@ module RailsAiContext
             # File extensions for fallback search (when ripgrep unavailable)
             # config.search_extensions = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
 
-            # Where to look for concern source files
-            # config.concern_paths = %w[app/models/concerns app/controllers/concerns]
+            # Where to look for concern source files. Left unset, every
+            # app/*/concerns directory is discovered. Setting this replaces
+            # that list, so it can narrow as well as reach outside app/.
+            # config.concern_paths = %w[app/models/concerns lib/concerns]
         SECTION
         "Frontend" => <<~SECTION
             # ── Frontend Framework Detection ─────────────────────────────────

data/lib/rails_ai_context/concern_paths.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # One answer to "where does this app keep its concerns", for every surface
+  # that lists or counts them.
+  #
+  # `GetConcern` hardcoded two directories and `ActiveSupportIntrospector`
+  # hardcoded five, so a single run answered 80 concerns and 81 concerns for
+  # the same app, and the mailer concern only the second one found could not be
+  # reached through the first at all. Neither list matches Rails, which
+  # autoloads these paths by glob - `Rails::Engine::Configuration#paths` adds
+  # `app` with `glob: "{*,*/concerns}"` - so any hardcoded list is one entry
+  # behind an app that keeps `app/serializers/concerns`.
+  module ConcernPaths
+    module_function
+
+    # @param root [String] application root
+    # @return [Array<String>] absolute concern directories that exist
+    def resolve(root)
+      # An app that names its concern directories means those and no others -
+      # the setting has to be able to narrow, or it only ever adds noise. It is
+      # unset by default, which is what asks for discovery.
+      configured = RailsAiContext.configuration.concern_paths
+      dirs =
+        if configured.nil?
+          Dir.glob(File.join(root, "app", "*", "concerns"))
+        else
+          # A path that is already absolute is taken as given; `File.join`
+          # would graft it onto the root and point at nothing.
+          Array(configured).map { |rel| File.absolute_path?(rel) ? rel : File.join(root, rel) }
+        end
+
+      dirs.uniq.select { |dir| Dir.exist?(dir) }.sort
+    end
+
+    # The owner segment names the type: `app/mailers/concerns` holds mailer
+    # concerns. Singular so a filter reads `type: "mailer"`.
+    def type_for(dir)
+      segment = dir[%r{/app/([^/]+)/concerns/?\z}, 1]
+      segment ? segment.singularize : "other"
+    end
+
+    # Source file for a concern named by its constant, or nil.
+    #
+    # @param root [String] application root
+    # @param concern_name [String] constant name, e.g. "BulkMailSettingsConcern"
+    def find_file(root, concern_name)
+      underscore = concern_name.to_s.underscore
+      return nil if underscore.empty? || underscore.include?("..")
+
+      resolve(root)
+        .map { |dir| File.join(dir, "#{underscore}.rb") }
+        .find { |path| File.exist?(path) }
+    end
+  end
+end

data/lib/rails_ai_context/configuration.rb

@@ -230,7 +230,7 @@ module RailsAiContext
 
     # Search and file discovery
     attr_accessor :search_extensions      # File extensions for Ruby fallback search (default: rb,js,erb,yml,yaml,json)
-    attr_accessor :concern_paths          # Where to look for concern source files (default: app/models/concerns)
+    attr_accessor :concern_paths          # Where to look for concern source files (default: nil, discovers app/*/concerns)
 
     # Frontend framework detection (optional overrides - auto-detected if nil)
     attr_accessor :frontend_paths         # User-declared frontend dirs (e.g. ["app/frontend", "../web-client"])
@@ -307,7 +307,7 @@ module RailsAiContext
       @ai_tools                 = nil
       @tool_mode                = :mcp
       @search_extensions        = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
-      @concern_paths            = %w[app/models/concerns app/controllers/concerns]
+      @concern_paths            = nil
       @frontend_paths           = nil
       @extra_app_paths          = []
       @query_timeout            = 5

data/lib/rails_ai_context/introspectors/active_support_introspector.rb

@@ -55,19 +55,10 @@ module RailsAiContext
         app.root.to_s
       end
 
-      CONCERN_DIRS = %w[
-        app/models/concerns
-        app/controllers/concerns
-        app/jobs/concerns
-        app/mailers/concerns
-        app/channels/concerns
-      ].freeze
-
       def extract_concerns
         result = {}
-        CONCERN_DIRS.each do |rel_dir|
-          dir = File.join(root, rel_dir)
-          next unless Dir.exist?(dir)
+        ConcernPaths.resolve(root).each do |dir|
+          rel_dir = dir.sub("#{root}/", "")
 
           modules = Dir.glob(File.join(dir, "**/*.rb")).sort.filter_map do |path|
             content = RailsAiContext::SafeFile.read(path) or next

data/lib/rails_ai_context/introspectors/auth_introspector.rb

@@ -132,8 +132,13 @@ module RailsAiContext
         # Pundit
         policies_dir = File.join(root, "app/policies")
         if Dir.exist?(policies_dir)
+          # Named from the path relative to app/policies, not the basename:
+          # Zeitwerk makes admin/collection_policy.rb `Admin::CollectionPolicy`,
+          # and demodulizing it collided with the top-level policy of the same
+          # base name, so one name was listed twice and the other class could
+          # not be reached from the context at all.
           policies = Dir.glob(File.join(policies_dir, "**/*.rb")).map do |f|
-            File.basename(f, ".rb").camelize
+            f.sub("#{policies_dir}/", "").delete_suffix(".rb").camelize
           end.sort
           authz[:pundit] = policies if policies.any?
         end

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -164,18 +164,76 @@ module RailsAiContext
       end
 
       # Prefer source-based parsing for actions - always reflects current file state.
-      # Falls back to reflection for controllers without readable source files.
+      #
+      # `action_methods` used to answer for a controller whose own file defines
+      # no public method, and it cannot: it subtracts inherited methods only as
+      # far as the nearest abstract ancestor, which is ActionController::Base.
+      # Everything ApplicationController and its concerns define publicly came
+      # back as an action, so a two-route controller reported 19 of them, most
+      # named things like `set_locale` and `pundit_user`.
+      #
+      # A thin subclass does still serve actions - its parent defines them - so
+      # the answer comes from the parent's source instead.
       def extract_actions(ctrl, source = nil)
-        if source
-          actions = extract_actions_from_source(source)
-          return actions if actions.any?
-        end
-        ctrl.action_methods.to_a.sort
+        own = extract_actions_from_source(source) if source
+        return own if own&.any?
+
+        inherited, unreadable_ancestor = inherited_actions(ctrl)
+        return inherited if inherited.any?
+
+        # An ancestor exists that this app does not own the source of, so what
+        # it defines is invisible here. `rails g devise:controllers` writes
+        # exactly this: the app owns the file, every action in it is commented
+        # out, and the gem class supplies them. Reflection brings inherited
+        # helpers along, which is worse than the alternative only if the
+        # alternative is not claiming the controller serves nothing.
+        return ctrl.action_methods.to_a.sort if unreadable_ancestor || source.nil?
+
+        # Every ancestor was readable and none defines an action. That is an
+        # answer, and reflection would only overwrite it with helpers.
+        []
       rescue => e
         $stderr.puts "[rails-ai-context] extract_actions failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
+      # The nearest ancestor in the app that defines actions of its own.
+      #
+      # The walk stops at ApplicationController by convention: it is where an
+      # app puts the helpers every controller shares, not actions, and reading
+      # it is what produced the leak above. A base class that only sets up
+      # filters contributes nothing and the walk continues past it.
+      #
+      # Returns the actions and whether the walk passed an ancestor whose
+      # source it could not read, which is what tells an empty answer apart
+      # from one this app cannot see.
+      def inherited_actions(ctrl)
+        unreadable = false
+        klass = ctrl.superclass
+        while klass&.name && !framework_controller?(klass) && !app_base_controller?(klass)
+          src = read_source(klass)
+          if src
+            actions = extract_actions_from_source(src)
+            return [ actions, unreadable ] if actions.any?
+          else
+            unreadable = true
+          end
+          klass = klass.superclass
+        end
+        [ [], unreadable ]
+      end
+
+      def framework_controller?(klass)
+        return true if klass.name.start_with?("ActionController::", "AbstractController::")
+        return true if klass == ActionController::Base
+        return true if defined?(ActionController::API) && klass == ActionController::API
+        false
+      end
+
+      def app_base_controller?(klass)
+        klass.name == "ApplicationController" || klass.name.end_with?("::ApplicationController")
+      end
+
       def extract_actions_from_source(source)
         ast_result = SourceIntrospector.walk_source(source, {
           methods: Listeners::MethodsListener
@@ -236,11 +294,7 @@ module RailsAiContext
       def collect_source_constraints(ctrl, current_source = nil)
         constraints = {}
         klass = ctrl
-        while klass && klass.name
-          break if klass.name.start_with?("ActionController::", "AbstractController::")
-          break if klass == ActionController::Base
-          break if defined?(ActionController::API) && klass == ActionController::API
-
+        while klass&.name && !framework_controller?(klass)
           src = (klass == ctrl) ? (current_source || read_source(klass)) : read_source(klass)
           if src
             extract_filters_from_source(src).each do |sf|

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

@@ -45,10 +45,17 @@ module RailsAiContext
             method:      "fetch",
             key:         key,
             has_default: args.size > 1 || !node.block.nil?,
+            # nil unless the fallback is a value that can be printed as one.
+            # `ENV.fetch("PORT", defaults[:port])` has a default, but naming
+            # it `defaults[:port]` puts a Ruby expression where a reader
+            # expects something to copy into a .env file.
+            default:     literal_value(args[1]),
             location:    node.location.start_line
           }
         end
 
+        # An interpolated name has no value at parse time, so it is not a
+        # variable name and this returns nil for it.
         def string_value(node)
           case node
           when Prism::StringNode then node.unescaped
@@ -56,6 +63,18 @@ module RailsAiContext
           else nil
           end
         end
+
+        def literal_value(node)
+          case node
+          when Prism::StringNode  then node.unescaped
+          when Prism::SymbolNode  then ":#{node.value}"
+          when Prism::IntegerNode, Prism::FloatNode then node.value.to_s
+          when Prism::TrueNode    then "true"
+          when Prism::FalseNode   then "false"
+          when Prism::NilNode     then "nil"
+          else nil
+          end
+        end
       end
     end
   end

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

@@ -14,27 +14,32 @@ module RailsAiContext
           @in_singleton_class = false
           @singleton_depth = 0
           @inline_visibility_stack = [ {} ] # stack of { method_name => visibility }
+          @owner_stack = []
         end
 
         # Reset visibility when entering a new class/module scope
         def on_class_node_enter(node)
           @visibility_stack.push(:public)
           @inline_visibility_stack.push({})
+          @owner_stack.push(constant_path_string(node.constant_path))
         end
 
         def on_class_node_leave(node)
           @visibility_stack.pop
           @inline_visibility_stack.pop
+          @owner_stack.pop
         end
 
         def on_module_node_enter(node)
           @visibility_stack.push(:public)
           @inline_visibility_stack.push({})
+          @owner_stack.push(constant_path_string(node.constant_path))
         end
 
         def on_module_node_leave(node)
           @visibility_stack.pop
           @inline_visibility_stack.pop
+          @owner_stack.pop
         end
 
         # Track `class << self` blocks
@@ -92,6 +97,13 @@ module RailsAiContext
             scope:        is_class_method ? :class : :instance,
             visibility:   visibility,
             params:       params,
+            # Enclosing class/module names, outermost first. A caller that
+            # wants one class's own methods needs this: a helper class nested
+            # inside a service is a separate owner, not part of its interface.
+            owner:        @owner_stack.dup,
+            # Sliced off the node so defaults read as written (`options = {}`);
+            # `params` records names only.
+            signature:    signature_source(node, is_class_method),
             location:     node.location.start_line,
             end_location: node.location.end_line,
             confidence:   RailsAiContext::Confidence::VERIFIED
@@ -100,6 +112,38 @@ module RailsAiContext
 
         private
 
+        # `class << self` members carry no receiver of their own, so they read
+        # as the bare name, which is how they are written.
+        def signature_source(node, is_class_method)
+          prefix = (is_class_method && node.receiver) ? "self." : ""
+          params = parameter_slices(node.parameters)
+          return "#{prefix}#{node.name}" if params.empty?
+
+          "#{prefix}#{node.name}(#{params.join(', ')})"
+        end
+
+        # Each parameter is sliced on its own rather than taking the whole list
+        # in one piece: a list split over several lines carries its newlines,
+        # and a comment written between two parameters would otherwise swallow
+        # the ones after it. Slicing keeps defaults as written, which is the
+        # reason for reading source here at all.
+        def parameter_slices(parameters)
+          return [] unless parameters
+
+          parts = []
+          %i[requireds optionals].each do |group|
+            next unless parameters.respond_to?(group)
+            parameters.public_send(group).each { |p| parts << p.location.slice }
+          end
+          parts << parameters.rest.location.slice if parameters.respond_to?(:rest) && parameters.rest
+          parameters.posts.each { |p| parts << p.location.slice } if parameters.respond_to?(:posts)
+          parameters.keywords.each { |p| parts << p.location.slice } if parameters.respond_to?(:keywords)
+          parts << parameters.keyword_rest.location.slice if parameters.respond_to?(:keyword_rest) && parameters.keyword_rest
+          parts << parameters.block.location.slice if parameters.respond_to?(:block) && parameters.block
+
+          parts.compact.map { |slice| slice.gsub(/\s+/, " ").strip }
+        end
+
         def extract_params(node)
           parameters = node.parameters
           return [] unless parameters

data/lib/rails_ai_context/introspectors/test_introspector.rb

@@ -298,13 +298,16 @@ module RailsAiContext
         nil
       end
 
+      # Only files named for a test framework are counted. Globbing every .rb
+      # counted whatever a project keeps beside its specs - mailer previews,
+      # shared contexts, page objects - under a heading that promises tests.
       def detect_test_count_by_category
         counts = {}
         %w[models controllers requests system services integration features helpers views jobs mailers channels].each do |cat|
           %w[spec test].each do |base|
             dir = File.join(root, base, cat)
             next unless Dir.exist?(dir)
-            count = Dir.glob(File.join(dir, "**/*.rb")).size
+            count = Dir.glob(File.join(dir, "**/*_{spec,test}.rb")).size
             counts[cat] = (counts[cat] || 0) + count if count > 0
           end
         end

data/lib/rails_ai_context/tools/get_callbacks.rb

@@ -244,10 +244,7 @@ module RailsAiContext
           next if concern_name.include?("::") && !concern_name.start_with?("App")
           next if %w[Kernel JSON PP Marshal].include?(concern_name)
 
-          underscore = concern_name.underscore
-          concern_path = RailsAiContext.configuration.concern_paths
-            .map { |dir| rails_app.root.join(dir, "#{underscore}.rb") }
-            .find { |p| File.exist?(p) }
+          concern_path = ConcernPaths.find_file(rails_app.root.to_s, concern_name)
           next unless concern_path
           next if File.size(concern_path) > max_size
 

data/lib/rails_ai_context/tools/get_concern.rb

@@ -16,8 +16,8 @@ module RailsAiContext
           },
           type: {
             type: "string",
-            enum: %w[model controller all],
-            description: "Filter by concern type. model: app/models/concerns/. controller: app/controllers/concerns/. all: both (default)."
+            enum: %w[model controller mailer job channel helper other all],
+            description: "Filter by concern type, named for the directory: model reads app/models/concerns/, mailer reads app/mailers/concerns/. other: a configured directory outside app/*/concerns. all: everything (default)."
           },
           detail: {
             type: "string",
@@ -36,6 +36,10 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
+      # Model and controller concerns lead because that is where most apps keep
+      # most of them; anything else follows in discovery order.
+      SECTION_ORDER = %w[model controller mailer job channel helper].freeze
+
       def self.call(name: nil, type: "all", detail: "standard", server_context: nil)
         root = rails_app.root.to_s
         max_size = RailsAiContext.configuration.max_file_size
@@ -56,27 +60,17 @@ module RailsAiContext
       end
 
       private_class_method def self.resolve_concern_dirs(root, type)
-        dirs = case type
-        when "model"
-          [ File.join(root, "app", "models", "concerns") ]
-        when "controller"
-          [ File.join(root, "app", "controllers", "concerns") ]
-        else
-          [
-            File.join(root, "app", "models", "concerns"),
-            File.join(root, "app", "controllers", "concerns")
-          ]
-        end
+        dirs = ConcernPaths.resolve(root)
+        return dirs if type.nil? || type == "all"
 
-        dirs.select { |d| Dir.exist?(d) }
+        dirs.select { |dir| ConcernPaths.type_for(dir) == type }
       end
 
       private_class_method def self.searched_dirs(type)
-        case type
-        when "model" then %w[app/models/concerns/]
-        when "controller" then %w[app/controllers/concerns/]
-        else %w[app/models/concerns/ app/controllers/concerns/]
-        end
+        return [ "app/*/concerns/" ] if type.nil? || type == "all"
+        return [ "any configured directory outside app/*/concerns" ] if type == "other"
+
+        [ "app/#{type.pluralize}/concerns/" ]
       end
 
       private_class_method def self.show_concern(name, concern_dirs, root, max_size, detail = "standard")
@@ -131,7 +125,7 @@ module RailsAiContext
           next if sensitive_file?(relative_real)
 
           file_path = real
-          concern_type = dir.include?("models") ? "model" : "controller"
+          concern_type = ConcernPaths.type_for(dir)
           break
         end
 
@@ -231,15 +225,18 @@ module RailsAiContext
           lines << "" << "## Included By (#{includers.size})"
           includers.each { |i| lines << "- #{i}" }
         else
-          lines << "" << "_No models or controllers found that include this concern._"
+          lines << "" << "_Nothing in #{includer_locations(concern_type)} includes this concern._"
         end
 
         # Cross-reference hints
         lines << ""
-        if concern_type == "model"
+        case concern_type
+        when "model"
           lines << "_Next: `rails_get_model_details(model:\"ModelName\")` for models using this concern_"
-        else
+        when "controller"
           lines << "_Next: `rails_get_controllers(controller:\"ControllerName\")` for controllers using this concern_"
+        else
+          lines << "_Next: `rails_search_code(pattern:\"include #{name.demodulize.camelize}\")` for everything using this concern_"
         end
 
         text_response(lines.join("\n"))
@@ -250,7 +247,7 @@ module RailsAiContext
         real_root = File.realpath(root).to_s
 
         concern_dirs.each do |dir|
-          concern_type = dir.include?("models") ? "model" : "controller"
+          concern_type = ConcernPaths.type_for(dir)
           real_dir = File.realpath(dir).to_s
           Dir.glob(File.join(dir, "**", "*.rb")).sort.each do |file_path|
             # Apply the 5-rule file-reading pattern per CLAUDE.md. Even though
@@ -295,22 +292,19 @@ module RailsAiContext
           return text_response("No concerns found in #{concern_dirs.map { |d| d.sub("#{root}/", "") }.join(', ')}.")
         end
 
-        model_concerns = all_concerns.select { |c| c[:type] == "model" }
-        controller_concerns = all_concerns.select { |c| c[:type] == "controller" }
-
         lines = [ "# Concerns (#{all_concerns.size})", "" ]
 
-        if model_concerns.any?
-          lines << "## Model Concerns (#{model_concerns.size})"
-          model_concerns.each do |c|
-            lines << "- **#{c[:name]}** - #{count_phrase(c[:method_count], "method")} (`#{c[:path]}`)"
-          end
-          lines << ""
-        end
-
-        if controller_concerns.any?
-          lines << "## Controller Concerns (#{controller_concerns.size})"
-          controller_concerns.each do |c|
+        # Grouped by whatever types the app actually has. Rendering a fixed
+        # pair of sections meant a concern outside them counted toward the
+        # total and then appeared nowhere, which is a worse answer than the
+        # undercount it replaced.
+        # Name breaks the tie: `sort_by` is not stable, so two types outside
+        # SECTION_ORDER would otherwise swap places between runs.
+        all_concerns.group_by { |c| c[:type] }
+                    .sort_by { |type, _| [ SECTION_ORDER.index(type) || SECTION_ORDER.size, type ] }
+                    .each do |type, concerns|
+          lines << "## #{type.camelize} Concerns (#{concerns.size})"
+          concerns.each do |c|
             lines << "- **#{c[:name]}** - #{count_phrase(c[:method_count], "method")} (`#{c[:path]}`)"
           end
           lines << ""
@@ -461,18 +455,26 @@ module RailsAiContext
         []
       end
 
+      # Names the directories find_includers actually searched, so the empty
+      # answer says where it looked rather than naming two it may not have.
+      private_class_method def self.includer_locations(concern_type)
+        return "app/models or app/controllers" if concern_type.nil? || concern_type == "other"
+        "app/#{concern_type.pluralize}"
+      end
+
       private_class_method def self.find_includers(concern_name, root, concern_type)
         includers = []
         search_dirs = []
 
-        case concern_type
-        when "model"
+        # The type names the directory that holds the includers: a mailer
+        # concern is included by mailers. Only a concern from outside
+        # app/*/concerns has no directory to name, so that one searches both
+        # of the places a concern is usually included from.
+        if concern_type.nil? || concern_type == "other"
           search_dirs << File.join(root, "app", "models")
-        when "controller"
           search_dirs << File.join(root, "app", "controllers")
         else
-          search_dirs << File.join(root, "app", "models")
-          search_dirs << File.join(root, "app", "controllers")
+          search_dirs << File.join(root, "app", concern_type.pluralize)
         end
 
         max_size = RailsAiContext.configuration.max_file_size

data/lib/rails_ai_context/tools/get_env.rb

@@ -264,25 +264,7 @@ module RailsAiContext
             next unless source
             next unless source.include?("ENV")
 
-            vars = []
-            source.each_line.with_index(1) do |line, line_num|
-              # A commented-out ENV mention is documentation, not usage.
-              next if line.lstrip.start_with?("#")
-
-              # ENV["VAR_NAME"] or ENV['VAR_NAME']
-              line.scan(/ENV\[["']([^"']+)["']\]/).each do |match|
-                vars << { name: match[0], line: line_num }
-              end
-
-              # ENV.fetch("VAR_NAME") or ENV.fetch("VAR_NAME", default)
-              line.scan(/ENV\.fetch\(["']([^"']+)["'](?:\s*,\s*([^)]+))?\)/).each do |match|
-                default = match[1]&.strip
-                # Sanitize default - don't expose potential secrets
-                default = sanitize_default(default) if default
-                vars << { name: match[0], line: line_num, default: default }
-              end
-            end
-
+            vars = env_references(source)
             env_vars[file] = vars if vars.any?
           end
         end
@@ -290,6 +272,35 @@ module RailsAiContext
         env_vars
       end
 
+      # The parser decides what counts as a name. A line scan matched whatever
+      # sat between the quotes, so an app that builds its variable names by
+      # interpolation - the normal shape for one carrying several Redis
+      # connections - had `#{prefix}URL` reported as a variable, in the very
+      # tool someone reaches for when writing a .env.example. Comments come out
+      # for free, including one trailing a line that also reads ENV.
+      private_class_method def self.env_references(source)
+        ast = Introspectors::SourceIntrospector.walk_source(
+          source, { env: -> { Introspectors::Listeners::EnvAccessListener.new } }
+        )
+
+        (ast[:env] || []).filter_map do |entry|
+          name = entry[:key]
+          # The parser already guaranteed a literal, so this only has to reject
+          # what is not a variable name at all. Deliberately looser than
+          # EnvIntrospector's uppercase rule: that one filters a catalogue of
+          # known Rails variables, while this lists whatever the app reads, and
+          # a lowercase `ENV["port"]` is still a variable the app reads.
+          next unless name.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+
+          var = { name: name, line: entry[:location] }
+          var[:default] = sanitize_default(entry[:default]) if entry[:default]
+          var
+        end
+      rescue => e
+        $stderr.puts "[rails-ai-context] env_references failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
       private_class_method def self.scan_env_example(root)
         # Only read .env.example or .env.sample - NEVER .env or .env.local
         candidates = %w[.env.example .env.sample .env.template]

data/lib/rails_ai_context/tools/get_model_details.rb

@@ -477,11 +477,7 @@ module RailsAiContext
       # Extract public method names from a concern's source file
       private_class_method def self.extract_concern_methods(concern_name)
         max_size = RailsAiContext.configuration.max_file_size
-        underscore = concern_name.underscore
-        # Search configurable concern paths
-        path = RailsAiContext.configuration.concern_paths
-          .map { |dir| rails_app.root.join(dir, "#{underscore}.rb") }
-          .find { |p| File.exist?(p) }
+        path = ConcernPaths.find_file(rails_app.root.to_s, concern_name)
         return nil unless path
         return nil if File.size(path) > max_size
 

data/lib/rails_ai_context/tools/get_service_pattern.rb

@@ -86,7 +86,7 @@ module RailsAiContext
         lines << "**Initialize:** `#{init_params}`" if init_params
 
         # Public methods
-        public_methods = extract_public_methods(source)
+        public_methods = extract_public_methods(source, constant_for(file, services_dir))
         if public_methods.any?
           lines << "" << "## Public Methods"
           public_methods.each { |m| lines << "- `#{m}`" }
@@ -139,7 +139,7 @@ module RailsAiContext
           relative = file.sub("#{root}/", "")
           class_name = extract_class_name(source) || File.basename(file, ".rb").camelize
           line_count = source.lines.size
-          public_methods = extract_public_methods(source)
+          public_methods = extract_public_methods(source, constant_for(file, services_dir))
 
           pattern_stats[:total] += 1
           has_initialize = source.match?(/def initialize/)
@@ -204,6 +204,13 @@ module RailsAiContext
         text_response(lines.join("\n"))
       end
 
+      # Zeitwerk requires the constant to match the path, and only the path
+      # carries the namespace: `admin/suspend_service.rb` is `Admin::SuspendService`,
+      # which no single `class` line in the file spells out.
+      private_class_method def self.constant_for(file, services_dir)
+        file.sub("#{services_dir}/", "").delete_suffix(".rb").camelize
+      end
+
       private_class_method def self.extract_class_name(source)
         match = source.match(/class\s+([\w:]+)/)
         match[1] if match
@@ -215,23 +222,39 @@ module RailsAiContext
         "initialize(#{match[1].strip})"
       end
 
-      private_class_method def self.extract_public_methods(source)
-        methods = []
-        in_private = false
-
-        source.each_line do |line|
-          in_private = true if line.match?(/\A\s*(private|protected)\s*$/)
-          in_private = false if line.match?(/\A\s*public\s*$/)
-          next if in_private
+      # A service's interface is the public methods of the service class
+      # itself. Nesting a query builder or a set of condition objects inside
+      # the service that uses them is a normal way to organise a large one, and
+      # a line scan cannot see that: it reported the nested class's first `def`
+      # as the entry point, and a `private` inside a nested class hid the real
+      # `call` that followed the nested class's `end`.
+      #
+      # `expected_constant` comes from the path rather than the source, the way
+      # JobIntrospector names its classes - Zeitwerk requires the two to agree,
+      # and only the path carries the namespace. A file that does not follow
+      # the convention falls back to the shallowest nesting, which is the
+      # outermost definition in the file.
+      private_class_method def self.extract_public_methods(source, expected_constant = nil)
+        ast = Introspectors::SourceIntrospector.walk_source(
+          source, { methods: Introspectors::Listeners::MethodsListener }
+        )
+        methods = ast[:methods] || []
+        return [] if methods.empty?
+
+        owner = primary_owner(methods, expected_constant)
+
+        methods.select { |m| m[:visibility] == :public && m[:owner].join("::") == owner }
+               .map { |m| m[:signature] }
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_public_methods AST failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
 
-          if (match = line.match(/\A\s*def\s+((?:self\.)?[\w?!]+(?:\([^)]*\))?)/))
-            sig = match[1]
-            next if sig.start_with?("initialize")
-            methods << sig
-          end
-        end
+      private_class_method def self.primary_owner(methods, expected_constant)
+        owners = methods.map { |m| m[:owner].join("::") }
+        return expected_constant if expected_constant && owners.include?(expected_constant)
 
-        methods
+        owners.min_by { |o| [ o.count(":"), o.length ] }
       end
 
       private_class_method def self.extract_dependencies(source, own_class_name)

data/lib/rails_ai_context/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.20.3
+  version: 5.21.0
 platform: ruby
 authors:
 - crisnahine
@@ -279,6 +279,7 @@ files:
 - lib/rails_ai_context/cli.rb
 - lib/rails_ai_context/cli/tool_runner.rb
 - lib/rails_ai_context/code_reloader.rb
+- lib/rails_ai_context/concern_paths.rb
 - lib/rails_ai_context/confidence.rb
 - lib/rails_ai_context/configuration.rb
 - lib/rails_ai_context/count_phrase.rb