rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/tools/analyze_feature.rb

@@ -40,6 +40,8 @@ module RailsAiContext
       # the filesystem. Tool output notes when the cap is hit so the AI agent knows
       # to narrow its feature keyword. v5.8.1 hardening; all glob sites in r2.
       MAX_SCAN_FILES = 500
+      # The callers named under each service; rails_get_service_pattern(service:) lists more.
+      CALLERS_SHOWN = 5
 
       # The directories rspec-rails and minitest file tests under by kind.
       SUITE_TYPE_DIRS = %w[
@@ -51,6 +53,11 @@ module RailsAiContext
       def self.call(feature:, server_context: nil)
         feature = feature.to_s.strip
         return text_response("Please provide a feature keyword (e.g. 'post', 'payment', 'authentication').") if feature.empty?
+        # Every layer word-matches the keyword against every name it holds, so
+        # a 100 KB keyword took ten seconds to match nothing.
+        if name_too_long?(feature)
+          return empty_response("No matches found for '#{echo_input(feature)}'. A feature keyword is a word or two, such as 'payment'.")
+        end
         ctx = cached_context
         pattern = feature.downcase
         root = rails_app.root.to_s
@@ -64,14 +71,14 @@ module RailsAiContext
         discover_jobs(ctx, pattern, lines)
         discover_views(ctx, root, pattern, lines)
         discover_stimulus(ctx, pattern, lines)
-        test_files, tests_truncated = discover_tests(root, pattern, lines)
+        _feature_tests, all_tests, tests_truncated = discover_tests(root, pattern, lines)
         discover_related_models(ctx, matched_models, lines)
         discover_concerns(ctx, matched_models, lines)
         discover_callbacks(ctx, matched_models, lines)
         discover_channels(ctx, pattern, lines)
         discover_mailers(ctx, pattern, lines)
         discover_env_dependencies(root, pattern, matched_models, lines)
-        discover_test_gaps(root, pattern, matched_models, ctx, test_files || [], lines, truncated: tests_truncated)
+        discover_test_gaps(root, pattern, matched_models, ctx, all_tests || [], lines, truncated: tests_truncated)
         discover_components(ctx, pattern, lines)
 
         # For auth-related keywords, also discover auth gems
@@ -95,7 +102,7 @@ module RailsAiContext
           else
             "\n\nThis app has no models yet, so there are no feature names to suggest."
           end
-          return text_response("No matches found for '#{feature}'. No models, controllers, routes, services, or views match this keyword.#{hint}")
+          return text_response("No matches found for '#{echo_input(feature)}'. No models, controllers, routes, services, or views match this keyword.#{hint}")
         end
 
         text_response(lines.join("\n"))
@@ -184,9 +191,11 @@ module RailsAiContext
                 lines << "**Enums:** #{enum_strs.join('; ')}"
               end
             end
+            # Only after a section: an empty one left a blank line per layer,
+            # four in a row under the heading of a feature with no models.
+            lines << ""
           end
 
-          lines << ""
           matched
         end
 
@@ -218,8 +227,8 @@ module RailsAiContext
                 lines << "- **Skipped filters:** #{split[:skipped].map { |n| "~~#{n}~~" }.join(', ')}"
               end
             end
+            lines << ""
           end
-          lines << ""
         end
 
         # --- AF: Routes ---
@@ -242,8 +251,8 @@ module RailsAiContext
                 lines << "- `#{r[:verb]}` `#{r[:path]}` → #{ctrl}##{r[:action]}#{helper}"
               end
             end
+            lines << ""
           end
-          lines << ""
         end
 
         # --- AF1: Services ---
@@ -252,6 +261,7 @@ module RailsAiContext
           return unless Dir.exist?(dir)
 
           real_root = File.realpath(root).to_s
+          real_dir = File.realpath(dir).to_s
           candidates = safe_glob(dir, "**/*.rb", real_root).first(MAX_SCAN_FILES)
           # Prefer basename match (fast, no file read) and only fall back to
           # a content scan for files whose basename doesn't match. This
@@ -262,20 +272,46 @@ module RailsAiContext
           end
           return if found.empty?
 
-          lines << "## Services (#{found.size}#{candidates.size == MAX_SCAN_FILES ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
-          found.each do |path|
-            relative = path.sub("#{real_root}/", "")
+          services = found.filter_map do |path|
             source = RailsAiContext::SafeFile.read(path) or next
-            line_count = source.lines.size
-            methods = source.scan(/^\s*def (?:self\.)?(\w+)/m).flatten.reject { |m| m == "initialize" }
-            lines << "- `#{relative}` (#{count_phrase(line_count, "line")})"
+            # The path carries the namespace Zeitwerk expects, as rails_get_service_pattern reads it.
+            constant = path.delete_prefix("#{real_dir}/").delete_suffix(".rb").camelize
+            { path: path, source: source, name: Introspectors::ServiceClasses.declaration(source, constant).first }
+          end
+          # A feature's services are usually run from controllers its name does
+          # not match: CheckoutService from two OrdersControllers.
+          named = services.select { |s| s[:name] }
+          callers, callers_truncated = GetServicePattern.callers_of(named.to_h { |s| [ s[:name], s[:path] ] }, real_root)
+
+          lines << "## Services (#{found.size}#{candidates.size == MAX_SCAN_FILES ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
+          services.each do |service|
+            relative = service[:path].sub("#{real_root}/", "")
+            methods = service[:name] ? service_methods(service[:source], service[:name]) : []
+            lines << "- `#{relative}` (#{count_phrase(service[:source].lines.size, "line")})"
             lines << "  Methods: #{methods.first(20).join(', ')}" if methods.any?
+            called_by = callers.fetch(service[:name], [])
+            next if called_by.empty?
+
+            more = called_by.size > CALLERS_SHOWN ? " and #{called_by.size - CALLERS_SHOWN} more" : ""
+            lines << "  Called by: #{called_by.first(CALLERS_SHOWN).map { |c| "`#{c}`" }.join(', ')}#{more}"
+          end
+          if callers_truncated
+            lines << "_The caller scan stopped after #{count_phrase(GetServicePattern::MAX_CALLER_SCAN_FILES, "file")}._"
           end
           lines << ""
         rescue => e
           RailsAiContext.debug_fail(e, nil, label: "discover_services")
         end
 
+        # The service class's own public methods, by the names Ruby calls
+        # them: a line scan listed `success` for CheckoutService, read off the
+        # `success?` of the Result struct nested in it.
+        def service_methods(source, name)
+          Introspectors::ActionResolver.own_methods_in(source, name)
+            .select { |m| m[:visibility] == :public }
+            .map { |m| m[:scope] == :class ? "self.#{m[:name]}" : m[:name].to_s }
+        end
+
         # --- AF2: Jobs ---
         def discover_jobs(ctx, pattern, lines)
           payload_section(Payload.jobs(ctx), pattern, lines, "Jobs") do |job|
@@ -285,6 +321,16 @@ module RailsAiContext
             bits << "perform(#{job[:perform_signature]})" if job[:perform_signature]
             bits.any? ? " (#{bits.join(', ')})" : ""
           end
+          # A Sidekiq worker is not an ActiveJob job, and in an app that runs
+          # its background work that way it is the only job there is.
+          payload_section(Payload.workers(ctx), pattern, lines, "Sidekiq Workers") do |worker|
+            bits = []
+            queue = (worker[:options] || {}).find { |key, _| key.to_s == "queue" }&.last
+            bits << "queue: #{queue}" if queue
+            bits << Array(worker[:retries]).join("; ") if Array(worker[:retries]).any?
+            bits << "#{worker[:entry_point] || "perform"}(#{worker[:perform_signature]})" if worker[:perform_signature]
+            bits.any? ? " (#{bits.join(', ')})" : ""
+          end
         end
 
         # The jobs, mailers and channels the :jobs introspector read, matched
@@ -386,9 +432,13 @@ module RailsAiContext
           relative.sub(%r{(\A|/)(?:spec|test)_}, "\\1")
         end
 
+        # @return [Array(Array<String>, Array<String>, Boolean)] the tests the
+        #   feature word names, every test read (relative to the suite's root),
+        #   and whether a glob stopped at MAX_SCAN_FILES
         def discover_tests(root, pattern, lines)
           real_root = File.realpath(root).to_s
           found = []
+          all = []
           truncated = false
 
           base = RailsAiContext::PathResolver.test_root(root)
@@ -409,9 +459,11 @@ module RailsAiContext
             prefix_glob.each do |path|
               found << path if feature_word_match?(relative_test_name(path, real_base), pattern)
             end
+            all.concat(suffix_glob, prefix_glob)
           end
           found.uniq!
-          return [ found, truncated ] if found.empty?
+          all = all.uniq.map { |path| path.delete_prefix("#{real_base}/") }
+          return [ found, all, truncated ] if found.empty?
 
           header = "## Tests (#{found.size}#{truncated ? " - first #{MAX_SCAN_FILES} per glob scanned" : ""})"
           lines << header
@@ -424,9 +476,9 @@ module RailsAiContext
             lines << "- `#{relative}` (#{count_phrase(test_count, "test")})"
           end
           lines << ""
-          [ found, truncated ]
+          [ found, all, truncated ]
         rescue => e
-          RailsAiContext.debug_fail(e, [ [], false ], label: "discover_tests")
+          RailsAiContext.debug_fail(e, [ [], [], false ], label: "discover_tests")
         end
 
         # --- Test coverage gaps ---
@@ -441,8 +493,10 @@ module RailsAiContext
           # Paths, not basenames: a namespaced name underscores to admin/badges,
           # which no basename can contain, so every namespaced controller was
           # reported as having no test - Discourse's Admin::BadgesController
-          # against spec/requests/admin/badges_controller_spec.rb.
-          test_basenames = test_files.map { |f| f.to_s.sub(/\.rb\z/, "").sub("#{root}/", "") }
+          # against spec/requests/admin/badges_controller_spec.rb. Every test
+          # in the suite, not only those the feature word names: the auth rule
+          # matches User for `authentication`, a word its user_test.rb lacks.
+          test_basenames = test_files.map { |f| f.to_s.sub(/\.rb\z/, "") }
 
           # Check models
           matched_models&.each do |name, _data|
@@ -544,7 +598,7 @@ module RailsAiContext
             next unless data.is_a?(Hash)
             (data[:callbacks] || {}).each do |type, methods|
               next unless methods.is_a?(Array)
-              methods.each { |m| callbacks << "#{name}: #{type} #{callback_target(m)}" }
+              methods.each { |m| callbacks << "#{name}: #{callback_type_label(type)} #{callback_target(m)}" }
             end
           end
           return if callbacks.empty?

data/lib/rails_ai_context/tools/argument_schema.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module RailsAiContext
+  module Tools
+    # json_schemer, which mcp 1.x checks tool arguments with, words each error
+    # through I18n when the process has I18n, after asking it once whether
+    # json_schemer's own translations exist. Asking loads every locale file
+    # the app has, so where one does not parse, the question raised on every
+    # invalid argument (the answer is only kept when there is one) and the
+    # client got an internal error, stderr a stack trace, instead of
+    # "Invalid arguments: ...". When it raises, json_schemer is given the
+    # answer an app without its translations gets, and the check runs again.
+    class ArgumentSchema < MCP::Tool::InputSchema
+      def validate_arguments(arguments)
+        super
+      rescue ValidationError
+        raise
+      rescue StandardError => e
+        raise unless locale_failure?(e) && words_without_i18n!
+
+        super
+      end
+
+      private
+
+      # Only an error out of I18n loading the app's locale files: the answer
+      # is process-wide, so any other failure leaves json_schemer as it is.
+      # A YAML locale that does not parse raises I18n::InvalidLocaleData; a
+      # Ruby one raises its own error from inside I18n's loader.
+      def locale_failure?(error)
+        return true if defined?(::I18n::ArgumentError) && error.is_a?(::I18n::ArgumentError)
+
+        Array(error.backtrace).any? { |line| line.match?(%r{/i18n-[^/]+/lib/i18n/}) }
+      end
+
+      # Once: a check that fails the same way again has another cause. The
+      # answer is kept on the JSONSchemer module, where Result#i18n? reads it.
+      def words_without_i18n!
+        return false unless defined?(::JSONSchemer::Result) && ::JSONSchemer::Result.method_defined?(:i18n?)
+        return false if ::JSONSchemer.class_variable_defined?(:@@i18n) && ::JSONSchemer.class_variable_get(:@@i18n) == false
+
+        ::JSONSchemer.class_variable_set(:@@i18n, false)
+        true
+      end
+    end
+  end
+end