rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/introspectors/stimulus_introspector.rb

@@ -22,14 +22,14 @@ module RailsAiContext
         # the fingerprint and the conventions all share.
         def controller_paths(root)
           JS_ROOTS.flat_map { |dir| PathResolver.dirs_for(root, dir) }
-                  .flat_map { |js_root| controller_files(js_root).map { |path| [ path, js_root ] } }
+                  .flat_map { |js_root| controller_files(js_root, root).map { |path| [ path, js_root ] } }
                   .uniq(&:first).sort_by(&:first)
         end
 
         # Walked rather than globbed so node_modules is pruned instead of
         # entered: globbing one real frontend/node_modules costs seconds.
-        def controller_files(js_root)
-          FileWalk.each_file(js_root, skip: SKIP_DIRS).select { |path| File.basename(path).match?(CONTROLLER_FILE) }
+        def controller_files(js_root, root)
+          FileWalk.each_file(js_root, skip: SKIP_DIRS, root: root.to_s).select { |path| File.basename(path).match?(CONTROLLER_FILE) }
         end
 
         JS_FILE = /\.(?:js|ts|jsx|tsx)\z/
@@ -134,7 +134,7 @@ module RailsAiContext
         def js_files(root)
           JS_ROOTS.flat_map { |dir| PathResolver.dirs_for(root, dir) }
                   .flat_map { |js_root|
-                    FileWalk.each_file(js_root, skip: SKIP_DIRS + TEST_DIRS)
+                    FileWalk.each_file(js_root, skip: SKIP_DIRS + TEST_DIRS, root: root.to_s)
                             .select { |path| path.match?(JS_FILE) && !File.basename(path).match?(TEST_FILE) }
                   }
                   .uniq
@@ -312,7 +312,7 @@ module RailsAiContext
           dirs = TEMPLATE_KINDS.flat_map { |kind| PathResolver.dirs_for(root, kind) }.uniq
           dirs += PathResolver.view_dirs(root).reject { |views| dirs.any? { |dir| views == dir || views.start_with?("#{dir}/") } }
           dirs.flat_map { |dir|
-            FileWalk.each_file(dir, skip: SKIP_DIRS).select { |path| path.match?(TEMPLATE_FILE) }.sort
+            FileWalk.each_file(dir, skip: SKIP_DIRS, root: root.to_s).select { |path| path.match?(TEMPLATE_FILE) }.sort
           }.uniq
         end
 
@@ -405,6 +405,9 @@ module RailsAiContext
           targets: static_array(content, "targets", /["'](\w+)["']/),
           values: extract_values(content),
           actions: extract_actions(content),
+          # The methods the controller calls on itself (`this.render()`): one
+          # no markup names is a helper the copy-paste markup leaves out.
+          self_calls: content.scan(/\bthis\.(\w+)\s*\(/).flatten.uniq.presence,
           outlets: static_array(content, "outlets", /["']([^"']+)["']/),
           classes: static_array(content, "classes", /["']([^"']+)["']/),
           lifecycle: extract_lifecycle(content),
@@ -452,9 +455,14 @@ module RailsAiContext
         end
       end
 
+      # Stimulus calls these itself when a value, a target or an outlet
+      # changes, so no markup names them: `quantityValueChanged` was listed as
+      # an action and pasted as `click->cart#quantityValueChanged`.
+      CHANGE_CALLBACK = /\A\w+(?:ValueChanged|TargetConnected|TargetDisconnected|OutletConnected|OutletDisconnected)\z/
+
       def extract_actions(content)
         content.scan(/^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/).flatten
-               .reject { |m| %w[constructor connect disconnect initialize if else for while switch catch function].include?(m) }
+               .reject { |m| %w[constructor connect disconnect initialize if else for while switch catch function].include?(m) || m.match?(CHANGE_CALLBACK) }
       end
 
       def extract_import_graph(content)
@@ -491,6 +499,7 @@ module RailsAiContext
 
       def extract_lifecycle(content)
         hooks = content.scan(/\b(connect|disconnect|initialize)\s*\(\s*\)/).flatten.uniq
+        hooks += content.scan(/^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/).flatten.grep(CHANGE_CALLBACK).uniq
         hooks.any? ? hooks : nil
       rescue => e
         RailsAiContext.debug_fail(e, nil, label: "extract_lifecycle")

data/lib/rails_ai_context/introspectors/test_introspector.rb

@@ -427,7 +427,7 @@ module RailsAiContext
             end
           end
         end
-        shared.sort_by { |s| s[:name] }
+        shared.sort_by.with_index { |s, i| [ s[:name], i ] }
       rescue => e
         RailsAiContext.debug_fail(e, [], label: "detect_shared_examples")
       end

data/lib/rails_ai_context/introspectors/turbo_introspector.rb

@@ -60,7 +60,7 @@ module RailsAiContext
         each_view_line do |file, line, line_num|
           next unless line.include?("turbo_stream_from")
 
-          subscriptions << { stream: subscription_stream(line), file: file, line: line_num, snippet: line.strip }
+          subscriptions << { stream: subscription_stream(line), parts: subscription_parts(line), file: file, line: line_num, snippet: line.strip }
         end
         subscriptions
       rescue => e
@@ -130,8 +130,19 @@ module RailsAiContext
         args.map(&:strip).reject(&:empty?)
       end
 
+      # The src value whole, up to the comma or bracket that ends it at the top
+      # level: a match that stopped at the first `)` cut
+      # `product_comments_path(@product)` short of its own.
       def frame_src(line)
-        line[/src:\s*["']?([^"',\s)]+)/, 1]
+        start = line =~ /\bsrc:\s*/ or return nil
+        value = +""
+        RailsAiContext::Brackets.each_top_level(line[(start + Regexp.last_match(0).length)..], comments: :ruby) do |piece, kind|
+          break if kind == :comment || (kind == :char && [ ",", ")", "}" ].include?(piece))
+
+          value << piece
+        end
+        value = value.sub(/\s*(?:-?%>|\bdo\b).*\z/m, "").strip
+        value.empty? ? nil : value.gsub(/\A["']|["']\z/, "")
       end
 
       # `turbo_stream_from :notifications`, `"notifications"`, `@room`,
@@ -200,7 +211,7 @@ module RailsAiContext
           end
         end
 
-        { models: models.sort_by { |b| [ b[:model], b[:line] ] }, explicit: explicit }
+        { models: models.sort_by.with_index { |b, i| [ b[:model], b[:line], i ] }, explicit: explicit }
       rescue => e
         RailsAiContext.debug_fail(e, { models: [], explicit: [] }, label: "scan_broadcasts")
       end
@@ -211,15 +222,21 @@ module RailsAiContext
           next unless hit[:receiver].nil?
 
           owner ||= owner_name(record)
-          { model: owner, macro: hit[:name], stream: macro_stream(hit), file: record.file, line: hit[:line], snippet: hit[:snippet] }
+          { model: owner, macro: hit[:name], stream: macro_stream(hit), streams: macro_streams(hit, owner),
+            file: record.file, line: hit[:line], snippet: hit[:snippet] }
         end
       end
 
       def explicit_entries(record, hits)
+        owner = nil
         hits.map do |hit|
+          owner ||= owner_name(record)
           {
             method: hit[:name],
-            stream: call_stream(hit[:arguments].first),
+            stream: call_stream(hit[:arguments]),
+            parts: stream_parts(hit[:arguments], hit[:computed]),
+            # The class the call sits in, which an expression such as `user` is read against.
+            owner: owner,
             target: hit[:options][:target]&.to_s,
             partial: hit[:options][:partial]&.to_s,
             file: record.file,
@@ -229,6 +246,104 @@ module RailsAiContext
         end
       end
 
+      # A stream as the parts Turbo builds its name from: a literal (a symbol
+      # or a string) or an expression, which rails_get_turbo_map resolves to
+      # the record it names. A record streams under its GlobalID, so
+      # `[product, :reviews]` in a model and `@product, :reviews` in a view are
+      # one stream when both name a Product. Nil for an interpolated name,
+      # which only its text can be compared by. A `broadcast_*_to` call takes
+      # its stream as every positional argument, so `user, :notifications`
+      # and `[user, :notifications]` are the same two parts.
+      def stream_parts(arguments, computed)
+        parts = Array(arguments).flatten.map do |value|
+          case value
+          when Symbol then { literal: value.to_s }
+          when String
+            return nil if value.match?(/\A["'].*#\{/m)
+
+            Array(computed).include?(value) ? { expr: value } : { literal: value }
+          else return nil
+          end
+        end
+        parts.empty? ? nil : parts
+      end
+
+      # The streams a broadcast macro sends to (turbo-rails broadcastable.rb):
+      # `broadcasts` and `broadcasts_refreshes` to the stream they name, the
+      # model's plural by default, on create, and to the record itself on
+      # update and destroy; the `_to` forms to what the method a symbol names,
+      # or a lambda, returns for the record.
+      def macro_streams(hit, owner)
+        first = hit[:arguments].first
+        named = first.is_a?(Symbol) || (first.is_a?(String) && !Array(hit[:computed]).include?(first))
+        case hit[:name]
+        when "broadcasts", "broadcasts_refreshes"
+          plural = named ? first.to_s : owner.to_s.underscore.tr("/", "_").pluralize
+          [ [ { literal: plural } ], [ { expr: "self" } ] ]
+        else
+          parts = named ? [ { expr: first.to_s } ] : lambda_parts(first.to_s)
+          parts && [ parts ]
+        end
+      end
+
+      # `->(card) { [card.board, :cards] }`: each part read against the record
+      # the lambda is given, so `card.board` is the record's own `board`.
+      def lambda_parts(source)
+        lambda = first_node(AstCache.parse_string(source).value) { |node| node.is_a?(Prism::LambdaNode) } or return nil
+        param = lambda.parameters&.parameters&.requireds&.first
+        param_name = param.respond_to?(:name) ? param.name : nil
+        body = lambda.body&.body&.last or return nil
+        elements = body.is_a?(Prism::ArrayNode) ? body.elements : [ body ]
+        parts = elements.map do |element|
+          case element
+          when Prism::SymbolNode, Prism::StringNode then { literal: element.unescaped }
+          when Prism::CallNode
+            reads_param = element.receiver.is_a?(Prism::LocalVariableReadNode) && element.receiver.name == param_name
+            return nil unless reads_param && element.arguments.nil?
+
+            { expr: element.name.to_s }
+          when Prism::LocalVariableReadNode
+            return nil unless element.name == param_name
+
+            { expr: "self" }
+          else return nil
+          end
+        end
+        parts.empty? ? nil : parts
+      rescue StandardError => e
+        RailsAiContext.debug_fail(e, nil, label: "lambda_parts")
+      end
+
+      def first_node(node, &block)
+        return node if yield(node)
+
+        node.compact_child_nodes.each do |child|
+          found = first_node(child, &block)
+          return found if found
+        end
+        nil
+      end
+
+      # A view's `turbo_stream_from` arguments as stream parts: a symbol or a
+      # string is a literal, anything else an expression (`@product`,
+      # `current_user`) the tool resolves against the app's models.
+      def subscription_parts(line)
+        code = line[/turbo_stream_from\b.*?(?=\s*-?%>|\s*\bdo\b|\z)/m] or return nil
+        call = first_node(AstCache.parse_string(code).value) { |node| node.is_a?(Prism::CallNode) && node.name == :turbo_stream_from }
+        arguments = call&.arguments&.arguments&.reject { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return nil if arguments.nil? || arguments.empty?
+
+        arguments.map do |arg|
+          case arg
+          when Prism::SymbolNode, Prism::StringNode then { literal: arg.unescaped }
+          when Prism::InterpolatedStringNode then return nil
+          else { expr: arg.slice }
+          end
+        end
+      rescue StandardError => e
+        RailsAiContext.debug_fail(e, nil, label: "subscription_parts")
+      end
+
       # A concerns directory is an autoload root, so its path name carries no
       # `Concerns::` segment; every scan here names a class through this.
       def owner_name(record)
@@ -256,13 +371,17 @@ module RailsAiContext
       end
 
       # `"post_#{post.id}"` reads as `post_{id}`; a symbol, a string or a bare
-      # identifier as itself; anything else is dynamic.
-      def call_stream(argument)
-        text = argument.to_s
-        return normalize_interpolation(text) if text.match?(/\A["'].*#\{/)
-        return text if argument.is_a?(Symbol) || text.match?(/\A\w+\z/)
-
-        "(dynamic)"
+      # identifier as itself; anything else is dynamic. Several arguments
+      # are one stream, labelled part by part as a subscription is.
+      def call_stream(arguments)
+        labels = Array(arguments).flatten.map do |argument|
+          text = argument.to_s
+          next normalize_interpolation(text) if text.match?(/\A["'].*#\{/)
+          next text if argument.is_a?(Symbol) || text.match?(/\A\w+\z/)
+
+          return "(dynamic)"
+        end
+        labels.empty? ? "(dynamic)" : labels.join(", ")
       end
 
       def detect_morph_meta

data/lib/rails_ai_context/introspectors/view_introspector.rb

@@ -125,7 +125,7 @@ module RailsAiContext
         dir = File.join(root, "app/helpers")
         return [] unless Dir.exist?(dir)
 
-        Dir.glob(File.join(dir, "**/*.rb")).filter_map do |path|
+        FileWalk.glob(dir, "**/*.rb", root: root).filter_map do |path|
           source = RailsAiContext::SafeFile.read(path)
           next if source && !HelperNames.view_helper?(source, path, dir)
 
@@ -146,9 +146,9 @@ module RailsAiContext
         dir = File.join(root, "app/components")
         return [] unless Dir.exist?(dir)
 
-        Dir.glob(File.join(dir, "**/*.rb")).filter_map do |path|
+        FileWalk.glob(dir, "**/*.rb", root: root).map do |path|
           path.sub("#{dir}/", "").sub(/\.rb\z/, "")
-        end.sort
+        end
       end
 
       def detect_template_engines
@@ -184,7 +184,7 @@ module RailsAiContext
           end
         end
 
-        counts.sort_by { |_, v| -v }.to_h
+        counts.sort_by.with_index { |(_, v), i| [ -v, i ] }.to_h
       rescue => e
         RailsAiContext.debug_fail(e, {}, label: "detect_form_builders")
       end

data/lib/rails_ai_context/introspectors/view_template_introspector.rb

@@ -363,15 +363,21 @@ module RailsAiContext
       # A partial or template name: a path, never text with spaces or quotes in it.
       PARTIAL_NAME = %r{\A[\w./-]+\z}
       RENDER_NAMED = /(?:\b(?:partial|template)\s*:|:(?:partial|template)\s*=>)\s*["']([^"']+)["']/
+      # A partial named outside a render call: turbo_stream.prepend and the
+      # broadcast_* methods take `partial:`, and jbuilder renders one with
+      # `json.partial!` or `json.array! ..., partial:`.
+      PARTIAL_ARG = /(?:\bjson\.partial!\s*\(?\s*|\bpartial:\s*|:partial\s*=>\s*)(["'])([^"']+)\1/
       # `render @posts`, `render(post)`, `render @posts, cached: true`: a bare record or collection, or a
       # chain on one (`@post.comments.recent`), matched against "render <args>"; RenderedRecord reads the chain.
       IMPLICIT_RENDER = /\Arender\s*\(?\s*@?((?:[a-z_]\w*\.)*[a-z_]\w*)\s*(?:[,)]|\s(?:if|unless)\b|-?\s*\z)/
 
       def extract_partial_refs(content)
         refs = []
+        spans = []
         # The partial or template a render call names, positionally or as a
         # keyword anywhere in its arguments, with or without parentheses.
-        self.class.render_calls(content).each do |_, args|
+        self.class.render_calls(content).each do |at, args|
+          spans << (at...(at + args.length))
           named = [ args[RENDER_POSITIONAL, 2], *top_level(args).scan(RENDER_NAMED).flatten ].compact
           # An interpolated name is decided at runtime, not a partial on disk.
           refs.concat(named.select { |name| name.match?(PARTIAL_NAME) })
@@ -380,6 +386,14 @@ module RailsAiContext
           # The records' model names the partial; `replies` with class_name "Comment" renders comments/_comment.
           refs << (collection ? model.pluralize : model) if model
         end
+        # A render call's own arguments were read above, where a `partial:`
+        # key nested in its locals is no partial of its own.
+        content.to_enum(:scan, PARTIAL_ARG).each do
+          match = Regexp.last_match
+          next if spans.any? { |span| span.cover?(match.begin(0)) }
+
+          refs << match[2] if match[2].match?(PARTIAL_NAME)
+        end
         # Phlex: render ComponentName.new(...) or render(ComponentName.new(...))
         content.scan(/render[\s(]+([A-Z]\w+(?:::\w+)*)\.new/).each { |m| refs << m[0] }
         refs.uniq

data/lib/rails_ai_context/legacy_cleanup.rb

@@ -20,13 +20,16 @@ module RailsAiContext
     # @param root [String, Pathname] project root directory
     # @param io [IO] stream for output (stderr by default)
     # @param warn_only [Boolean] skip prompt even if TTY, only print warning
-    def prompt_legacy_files(ai_tools, root:, io: $stderr, warn_only: false)
+    # @param place [String, nil] the root as the person who typed the
+    #   command names it, when they typed it outside the root: the files and
+    #   the rm line are named from there, so the rm removes them where it is run
+    def prompt_legacy_files(ai_tools, root:, io: $stderr, warn_only: false, place: nil)
       allowed = ai_tools ? Array(ai_tools).map(&:to_sym).to_set : nil
 
       present = LEGACY_FILES.filter_map do |entry|
         next if allowed && !allowed.include?(entry[:ai_tool])
         full = File.join(root.to_s, entry[:path])
-        [ entry[:path], full ] if File.exist?(full)
+        [ place ? File.join(place, entry[:path]) : entry[:path], full ] if File.exist?(full)
       end
       return if present.empty?
 
@@ -38,7 +41,7 @@ module RailsAiContext
 
       if warn_only || !$stdin.tty?
         io.puts "Delete manually when ready:"
-        io.puts "  rm -f #{present.map(&:first).join(' ')}"
+        io.puts "  #{rm_line(present)}"
         return
       end
 
@@ -55,8 +58,18 @@ module RailsAiContext
         end
       else
         io.puts "  Kept. Delete manually when ready:"
-        io.puts "    rm -f #{present.map(&:first).join(' ')}"
+        io.puts "    #{rm_line(present)}"
       end
     end
+
+    # The rm a reader can paste: each path a single shell word.
+    def rm_line(present)
+      words = present.map do |(shown, _)|
+        next shown if shown.match?(%r{\A[A-Za-z0-9_\-.,:+/@]+\z})
+
+        "'#{shown.gsub("'") { %q('\\'') }}'"
+      end
+      "rm -f #{words.join(' ')}"
+    end
   end
 end

data/lib/rails_ai_context/live_reload.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  # Keeps a long-lived MCP server truthful: when the app changes, drop the
-  # tool caches and tell connected clients to re-query. The loop - watch
-  # list, fingerprint gate, code reload - is ChangeWatch's; this supplies
-  # the non-blocking background behavior, the debounce, and the
-  # cache-and-notify reaction. A missing `listen` gem raises out of start;
-  # Server#maybe_start_live_reload owns that policy.
+  # Tells connected clients when the app changed, so they re-query. Answers
+  # do not wait on it: each call checks the files itself before it reads
+  # anything (BaseTool.refresh_if_files_changed!). The loop - watch list,
+  # fingerprint gate - is ChangeWatch's; this supplies the non-blocking
+  # background behavior, the debounce, and the notification. A missing
+  # `listen` gem raises out of start; Server#maybe_start_live_reload owns
+  # that policy.
   class LiveReload
     include CountPhrase
 
@@ -27,7 +28,7 @@ module RailsAiContext
       end
 
       debounce = RailsAiContext.configuration.live_reload_debounce
-      listener = @watch.start(debounce: debounce) { |paths, reloaded| react(paths, reloaded) }
+      listener = @watch.start(debounce: debounce) { |paths| react(paths) }
       return unless listener
 
       # After the listener, not before: these lines are only true once a
@@ -46,7 +47,7 @@ module RailsAiContext
     # Run a batch of changed paths through the shared gate. Public for
     # testability - specs drive this instead of a real Listen thread.
     def handle_change(changed_paths = [])
-      @watch.gate(changed_paths) { |paths, reloaded| react(paths, reloaded) }
+      @watch.gate(changed_paths) { |paths| react(paths) }
     end
 
     # Group changed file paths by category (model, controller, etc.)
@@ -83,22 +84,21 @@ module RailsAiContext
 
     private
 
-    # The gate already reloaded the app's code; dropping the caches after
-    # that order is what keeps the server from answering with constants
-    # Rails autoloaded at boot.
-    def react(paths, reloaded)
-      Tools::BaseTool.reset_all_caches!
-
+    # On Listen's thread, so it loads no app code (see ChangeWatch#gate), and
+    # it drops no cache either: the first call after the edit already did,
+    # when it checked the files, or the next one will. A reload or a drop
+    # here would only repeat that call's work, a full introspection a second
+    # and a half after every edit.
+    def react(paths)
       message = format_change_message(categorize_changes(paths))
+      unless CodeReloader.reloadable?
+        message += " RAILS_ENV=#{RailsAiContext.environment_name} does not reload code, so what reflection reads stays as of boot."
+      end
 
       mcp_server.notify_resources_list_changed
-      mcp_server.notify_log_message(
-        data: "#{message} Tool caches invalidated#{reloaded ? " and app code reloaded" : ""}.",
-        level: "info",
-        logger: "rails-ai-context"
-      )
+      mcp_server.notify_log_message(data: message, level: "info", logger: "rails-ai-context")
 
-      $stderr.puts "[rails-ai-context] #{message} Tool caches invalidated#{reloaded ? " and app code reloaded" : ""}."
+      $stderr.puts "[rails-ai-context] #{message}"
     rescue => e
       $stderr.puts "[rails-ai-context] Live reload error: #{e.message}"
     end