rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/schema_reader.rb

@@ -23,25 +23,30 @@ module RailsAiContext
       # a dump that parses to zero tables falls through to the next source.
       def self.for(root)
         root = root.to_s
+        # One parse per run however many introspectors ask.
+        RailsAiContext::RunCache.fetch([ :schema_reader, root ]) { choose(root) }
+      end
 
-        schema_rb = File.join(root, "db", "schema.rb")
-        if File.exist?(schema_rb)
-          reader = new(schema_rb, pk_type: SchemaConventions.implicit_pk_type(root, schema_rb))
-          return reader.with_source(:schema_rb) if reader.tables.any?
-        end
+      def self.choose(root)
+        return from_tables({}, source: :none, path: nil) if RailsAiContext::AppKind.sequel_schema(root)
+
+        candidates = SchemaDumpPath.candidates(root)
+        candidates.each do |format, path|
+          next unless File.exist?(path)
 
-        structure = File.join(root, "db", "structure.sql")
-        if File.exist?(structure)
-          content = RailsAiContext::SafeFile.read(structure, max_size: RailsAiContext.configuration.max_schema_file_size)
-          if content
-            parsed = StructureSqlReader.parse(content)
-            return from_tables(parsed[:tables], source: :structure_sql, path: structure) if parsed[:tables].any?
+          if format == :ruby
+            reader = new(path, pk_type: SchemaConventions.implicit_pk_type(root))
+            return reader.with_source(:schema_rb) if reader.tables.any?
+          else
+            content = RailsAiContext::SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
+            parsed = content && StructureSqlReader.parse(content)
+            return from_tables(parsed[:tables], source: :structure_sql, path: path, views: parsed[:views]) if parsed && parsed[:tables].any?
           end
         end
 
         migrate_dirs = MigrationReplay.migration_dirs(root)
-        if MigrationReplay.migration_files(migrate_dirs).any?
-          pk_type = SchemaConventions.implicit_pk_type(root, schema_rb)
+        if MigrationReplay.migration_files(migrate_dirs, root: root).any?
+          pk_type = SchemaConventions.implicit_pk_type(root)
           return from_tables(MigrationReplay.tables(migrate_dirs, pk_type: pk_type, root: root),
                              source: :migrations, path: migrate_dirs.first)
         end
@@ -51,9 +56,9 @@ module RailsAiContext
 
       # A reader over an already-parsed tables hash, for the sources that do
       # not go through the schema.rb event fold.
-      def self.from_tables(tables, source:, path:)
+      def self.from_tables(tables, source:, path:, views: {})
         reader = allocate
-        reader.send(:initialize_from_tables, tables, source, path)
+        reader.send(:initialize_from_tables, tables, source, path, views)
         reader
       end
 
@@ -89,11 +94,31 @@ module RailsAiContext
         parse[:enums]
       end
 
-      # @return [Array<Hash>] { table:, expression: } per declared constraint
+      # @return [Array<Hash>] { table:, name:, expression: } per declared constraint, name when given
       def check_constraints
         parse[:check_constraints]
       end
 
+      # @return [Array<String>] the extensions the dump enables
+      def extensions
+        parse[:extensions]
+      end
+
+      # @return [Hash] view name => { materialized:, sql: }
+      def views
+        parse[:views]
+      end
+
+      # @return [Hash] virtual table name => { module:, arguments: }
+      def virtual_tables
+        parse[:virtual_tables]
+      end
+
+      # @return [Hash] table name => why the dumper wrote a comment in its place
+      def not_dumped
+        parse[:not_dumped]
+      end
+
       # Declared defaults for one table, as source text. Callers report these
       # verbatim when the live database returns no default.
       def defaults_for(table)
@@ -114,7 +139,7 @@ module RailsAiContext
 
       attr_reader :path
 
-      def initialize_from_tables(tables, source, path)
+      def initialize_from_tables(tables, source, path, views)
         @path = path
         @pk_type = nil
         @source = source
@@ -123,10 +148,15 @@ module RailsAiContext
           # structure.sql and the replay keep from_table/to_table on the table;
           # every reader answers the schema.rb shape, so no consumer checks both.
           foreign_keys: tables.flat_map { |_name, t| t[:foreign_keys] || [] }.map do |fk|
-            { from: fk[:from_table], to: fk[:to_table], column: fk[:column], primary_key: fk[:primary_key] }.compact
+            { from: fk[:from_table], to: fk[:to_table], column: fk[:column], primary_key: fk[:primary_key],
+              on_delete: fk[:on_delete], on_update: fk[:on_update] }.compact
           end,
           enums: [],
-          check_constraints: []
+          check_constraints: [],
+          extensions: [],
+          views: views,
+          virtual_tables: {},
+          not_dumped: {}
         }
       end
 
@@ -139,7 +169,7 @@ module RailsAiContext
       end
 
       def empty_schema
-        { tables: {}, foreign_keys: [], enums: [], check_constraints: [] }
+        { tables: {}, foreign_keys: [], enums: [], check_constraints: [], extensions: [], views: {}, virtual_tables: {}, not_dumped: {} }
       end
 
       def build
@@ -213,18 +243,27 @@ module RailsAiContext
         when :unread_call
           SchemaConventions.note_unread_call(schema[:tables][current], event[:name]) if current
         when :add_index
-          schema[:tables][event[:table]]&.dig(:indexes)&.push(index_entry(event))
+          target = schema[:tables][event[:table]] || schema[:views][event[:table]]
+          (target[:indexes] ||= []) << index_entry(event) if target
         when :foreign_key
-          schema[:foreign_keys] << {
-            from: event[:from], to: event[:to],
-            column: event[:column], primary_key: event[:primary_key]
-          }.compact
+          schema[:foreign_keys] << event.slice(:from, :to, :column, :primary_key, *SchemaConventions::FOREIGN_KEY_OPTIONS)
+        when :unique_constraint
+          table = schema[:tables][current] if current
+          (table[:unique_constraints] ||= []) << event.slice(:columns, :options) if table
+        when :extension
+          schema[:extensions] << event[:name]
         when :enum
           schema[:enums] << { name: event[:name], values: event[:values] }
         when :check_constraint
-          schema[:check_constraints] << { table: current, expression: event[:expression] } if current
+          schema[:check_constraints] << { table: current, **event.slice(:name, :expression) } if current
         when :add_check_constraint
-          schema[:check_constraints] << { table: event[:table], expression: event[:expression] }
+          schema[:check_constraints] << event.slice(:table, :name, :expression)
+        when :view
+          schema[:views][event[:name]] = { materialized: event[:materialized], sql: event[:sql] }
+        when :virtual_table
+          schema[:virtual_tables][event[:name]] = event.slice(:module, :arguments)
+        when :not_dumped
+          schema[:not_dumped][event[:table]] = event[:reason]
         end
 
         current
@@ -236,8 +275,9 @@ module RailsAiContext
           name:    column_name(event),
           type:    event[:column_type],
           default: default_for(event, options),
-          options: options
-        }
+          options: options,
+          virtual: event[:virtual]
+        }.compact
       end
 
       def index_entry(event)

data/lib/rails_ai_context/introspectors/service_classes.rb

@@ -2,28 +2,32 @@
 
 module RailsAiContext
   module Introspectors
-    # Which classes under app/services are services and which are only a base. The tool's
+    # Which classes under the service roots are services and which are only a base. The tool's
     # listing and the generated Services line both ask here, so they name one set.
     module ServiceClasses
+      # active_interaction recommends app/interactions, and interactor-rails
+      # autoloads and generates into app/interactors.
+      ROOTS = %w[app/services app/interactions app/interactors].freeze
+
       module_function
 
       # The declared constant and its superclass from one parse; the path fills in a
       # namespace the source leaves out.
       #
-      # @return [Array(String, String)] name, superclass
+      # @return [Array(String, String, Array<String>)] name, superclass, the nesting it is read in
       def declaration(source, path_name)
-        own = DeclaredConstant.declaration_for(DeclaredConstant.declarations(source), path_name)
-        [ own&.name || DeclaredConstant.resolve(source, path_name), own&.superclass ]
+        own = DeclaredConstant.declaration_for(DeclaredConstant.declarations(source, path_name: path_name), path_name)
+        [ own&.name || DeclaredConstant.resolve(source, path_name), own&.superclass, own&.nesting ]
       end
 
-      # The bases among the given [name, superclass] pairs: a Base-named class
+      # The bases among the given [name, superclass, nesting] triples: a Base-named class
       # something else in the list inherits from, or one of Rails' own.
-      def abstract_names(pairs)
-        named = pairs.map(&:first).select { |name| SuperclassChain.abstract_base_name?(name) }
+      def abstract_names(declared)
+        named = declared.map(&:first).select { |name| SuperclassChain.abstract_base_name?(name) }
         return [] if named.empty?
 
-        inherited = pairs.filter_map do |name, superclass|
-          SuperclassChain.resolve_in_scope(name, superclass) { |candidate| candidate if named.include?(candidate) }
+        inherited = declared.filter_map do |name, superclass, nesting|
+          SuperclassChain.resolve_in_scope(name, superclass, nesting: nesting) { |candidate| candidate if named.include?(candidate) }
         end
         named.select { |name| SuperclassChain.abstract_base?(name, inherited: inherited.include?(name)) }.uniq.sort
       end
@@ -82,14 +86,16 @@ module RailsAiContext
         pairs = []
         modules = []
         lookup = SuperclassChain.lookup_for(root)
-        SourceScan.each(root, kind: "app/services") do |record|
-          next if concern?(record.file, record.source)
+        ROOTS.each do |kind|
+          SourceScan.each(root, kind: kind) do |record|
+            next if concern?(record.file, record.source)
 
-          name, superclass = declaration(record.source, record.path_name)
-          next if mailer?(record.source, name, superclass, lookup)
+            name, superclass, nesting = declaration(record.source, record.path_name)
+            next if mailer?(record.source, name, superclass, lookup)
 
-          pairs << [ name, superclass ]
-          modules << name if entryless_module?(record.source, name)
+            pairs << [ name, superclass, nesting ]
+            modules << name if entryless_module?(record.source, name)
+          end
         end
         left_out = abstract_names(pairs) + mixed_in(root, modules)
         pairs.map(&:first).reject { |name| left_out.include?(name) }.uniq.sort

data/lib/rails_ai_context/introspectors/source_calls.rb

@@ -19,7 +19,7 @@ module RailsAiContext
       # framework, the standard library, and the app's record base.
       IGNORED = %w[
         Rails ActiveRecord ApplicationRecord File Dir ENV String Integer Float
-        Array Hash Set Time Date DateTime URI Regexp
+        Array Hash Set Time Date DateTime URI Regexp Class
       ].freeze
 
       # `::Foo::Bar` and `Foo::Bar` are one constant; the root operator is not part of the name.

data/lib/rails_ai_context/introspectors/source_introspector.rb

@@ -49,8 +49,9 @@ module RailsAiContext
       end
 
       # Walk a file with a custom listener map. Returns { key => results_array }.
-      def self.walk(path, listener_map = LISTENER_MAP)
-        result = AstCache.parse(path)
+      # A caller that already read the file passes `source`, so its other reads share the parse.
+      def self.walk(path, listener_map = LISTENER_MAP, source: nil)
+        result = source ? AstCache.parse_string(source) : AstCache.parse(path)
         walk_dispatch(result, listener_map)
       end
 
@@ -60,6 +61,20 @@ module RailsAiContext
         walk_dispatch(result, listener_map)
       end
 
+      # The calls a class body makes itself, out of what one walk found: a call
+      # inside a `def` runs only when the method is called.
+      def self.outside_defs(calls, methods)
+        bodies = methods.respond_to?(:def_spans) ? methods.def_spans : Array(methods).filter_map { |m| m[:offset]...m[:end_offset] if m[:offset] && m[:end_offset] }
+        Array(calls).reject { |call| call[:offset] && bodies.any? { |range| range.cover?(call[:offset]) } }
+      end
+
+      # The calls a class body makes itself, out of a walk that ran MethodsListener as `methods:` and
+      # NestedConstantsListener as `nested:`: a class or module it nests declares only for itself.
+      def self.class_level(calls, walked)
+        nested = Array(walked[:nested])
+        outside_defs(calls, walked[:methods]).reject { |call| call[:offset] && nested.any? { |range| range.cover?(call[:offset]) } }
+      end
+
       # Walk a parse result the caller already holds, so a second reader of the
       # same source does not parse it again.
       def self.walk_dispatch(parse_result, listener_map)

data/lib/rails_ai_context/introspectors/source_scan.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module RailsAiContext
   module Introspectors
     # One walk over a kind of app source: every directory PathResolver
@@ -25,46 +27,190 @@ module RailsAiContext
         end.each(&block)
       end
 
-      def scan(root, kind, skip_concerns)
+      def scan(root, kind, skip_concerns, &block)
         root = root.to_s
         real_root = File.realpath(root)
         PathResolver.dirs_for(root, kind).each do |dir|
-          real_dir = File.realpath(dir)
-          Dir.glob(File.join(dir, "**", "*.rb")).sort.each do |path|
-            relative_to_dir = path.delete_prefix(dir + File::SEPARATOR)
-            next if skip_concerns && relative_to_dir.start_with?("concerns/")
+          scan_dir(dir, root, real_root, skip_concerns, &block)
+        end
+      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+        nil
+      end
 
-            real = File.realpath(path)
-            next unless SafePath.contained?(real, real_dir)
+      def scan_dir(dir, root, real_root, skip_concerns)
+        real_dir = File.realpath(dir)
+        ruby_files(dir, real_dir, [ real_dir, real_root ], Set.new).sort_by(&:first).each do |path, real|
+          relative_to_dir = path.delete_prefix(dir + File::SEPARATOR)
+          next if skip_concerns && relative_to_dir.start_with?("concerns/")
+          next unless within?(real, real_dir, real_root)
+
+          path_name = relative_to_dir.sub(/\.rb\z/, "").split("/").map(&:camelize).join("::")
+          yield Record.new(path: real, file: relative_file(path, real, root, real_root), path_name: path_name, source: nil)
+        end
+      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+        nil
+      end
+
+      # Zeitwerk follows symlinks, so the walk does too, as far as the app's
+      # own tree; a directory reached twice (a link back up) is walked once.
+      # Linked directories wait until the real tree is done, so a directory
+      # both spell is named by its real path whatever order the disk lists.
+      # Each entry is [path as spelled, real path].
+      def ruby_files(dir, real_dir, bounds, visited)
+        pending = [ [ dir, real_dir ] ]
+        found = []
+        found.concat(walk_dir(*pending.shift, bounds, visited, pending)) while pending.any?
+        found
+      end
+
+      # One lstat per entry: below a real directory only a link needs a realpath.
+      def walk_dir(dir, real_dir, bounds, visited, links)
+        return [] unless visited.add?(real_dir)
+
+        Dir.children(dir).sort.flat_map do |name|
+          next [] if name.start_with?(".")
 
-            path_name = relative_to_dir.sub(/\.rb\z/, "").split("/").map(&:camelize).join("::")
-            yield Record.new(path: real, file: relative_file(path, real, root, real_root), path_name: path_name, source: nil)
-          rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
-            next
+          path = File.join(dir, name)
+          stat = File.lstat(path)
+          if stat.symlink?
+            real = File.realpath(path)
+            if !File.directory?(real)
+              name.end_with?(".rb") ? [ [ path, real ] ] : []
+            else
+              links << [ path, real ] if within?(real, *bounds)
+              []
+            end
+          elsif stat.directory?
+            walk_dir(path, File.join(real_dir, name), bounds, visited, links)
+          else
+            name.end_with?(".rb") ? [ [ path, File.join(real_dir, name) ] ] : []
           end
         rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
-          next
+          []
         end
       rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
-        nil
+        []
+      end
+
+      def within?(real, real_dir, real_root)
+        SafePath.contained?(real, real_dir) || SafePath.contained?(real, real_root)
+      end
+
+      # The model directories plus the classes elsewhere that could be a model.
+      # Only the model listing wants the second half: a count or a per-model
+      # read of app/models would take in every service with a superclass.
+      # A booted caller passes `base_model`, called with the names a superclass the scan does not
+      # know resolves to, innermost scope first, since a gem or initializer can define it.
+      def model_paths(root, base_model: nil, &block)
+        return enum_for(:model_paths, root, base_model: base_model) unless block
+
+        RunCache.fetch([ :source_scan_models, root.to_s, !base_model.nil? ]) do
+          found = paths(root, kind: "app/models", skip_concerns: false).to_a
+          found + extra_model_candidates(root.to_s, found, base_model)
+        end.each(&block)
+      end
+
+      CLASS_WITH_SUPERCLASS = /class[^\S\n]+([\w:]+)[^\S\n]*<[^\S\n]*([\w:]+)/
+      MODEL_BASES = %w[ActiveRecord::Base ApplicationRecord].freeze
+
+      # A model can live in any autoload root; a class there is kept when its superclass is a model base,
+      # a model or a class already kept, so a thousand services are not parsed.
+      def extra_model_candidates(root, model_records, base_model = nil)
+        pending, declared = RunCache.fetch([ :source_scan_model_declarations, root ]) { extra_model_declarations(root, File.realpath(root)) }
+        known = model_records.to_set(&:path_name).merge(MODEL_BASES)
+        declared = declared | known
+        loaded = Hash.new { |cache, candidates| cache[candidates] = base_model ? base_model.call(candidates) : false }
+        kept = Set.new
+        loop do
+          added = pending.select do |record, pairs|
+            !kept.include?(record) && pairs.any? do |name, base|
+              # Ruby takes the innermost lexical scope that declares the name;
+              # a compact `class Admin::Item < Base` has none, a nested one has the path's.
+              candidates = lookup(record.path_name, name, base).reverse
+              resolved = candidates.find { |candidate| declared.include?(candidate) }
+              resolved ? known.include?(resolved) : loaded[candidates]
+            end
+          end
+          break if added.empty?
+
+          added.each do |record, pairs|
+            kept << record
+            known.merge(pairs.map { |name, _| qualified(record.path_name, name) })
+          end
+        end
+        pending.filter_map { |record, _| record if kept.include?(record) }
+      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+        []
+      end
+
+      # The names `base` can mean where `name` is declared in the file `path_name` names, outermost first.
+      def lookup(path_name, name, base = name)
+        return [ base.delete_prefix("::") ] if base.start_with?("::")
+
+        scopes = path_name.split("::")[0...-name.split("::").size]
+        (0..scopes.size).map { |depth| [ *scopes.first(depth), base ].join("::") }
+      end
+
+      # The constant a `class name` line in the file `path_name` names declares.
+      def qualified(path_name, name)
+        return name.delete_prefix("::") if name.start_with?("::")
+
+        name.include?("::") ? name : lookup(path_name, name).last
+      end
+
+      # The candidates, and every name the scanned files declare by path or by a superclassed class.
+      def extra_model_declarations(root, real_root)
+        seen = Set.new
+        declared = Set.new
+        ignored = PathResolver.ignored_dirs(root).map { |dir| PathResolver.root_key(dir) }
+        found = PathResolver.extra_model_roots(root).each_with_object([]) do |dir, records|
+          scan_dir(dir, root, real_root, true) do |record|
+            next unless seen.add?(record.path)
+            next if ignored.any? { |ignored_dir| SafePath.contained?(record.path, ignored_dir) }
+
+            declared << record.path_name
+            pairs = class_declarations(SafeFile.read(record.path).to_s)
+            next if pairs.empty?
+
+            records << [ record, pairs ]
+            pairs.each { |name, _| declared << qualified(record.path_name, name) }
+          end
+        end
+        [ found, declared ]
+      end
+
+      # [name, superclass] of each `class X < Y` that starts its line. A `^` anchor
+      # makes Onigmo try every offset, ten times slower over a service tree.
+      def class_declarations(source)
+        pairs = []
+        source.scan(CLASS_WITH_SUPERCLASS) do |name, base|
+          start = Regexp.last_match.begin(0)
+          line_start = start.zero? ? 0 : (source.rindex("\n", start - 1) || -1) + 1
+          pairs << [ name, base ] if source[line_start...start].match?(/\A[^\S\n]*\z/)
+        end
+        pairs
       end
 
-      private_class_method :scan
+      private_class_method :scan, :scan_dir, :ruby_files, :walk_dir, :within?, :extra_model_candidates, :extra_model_declarations, :class_declarations, :lookup, :qualified
 
-      def each(root, kind:, skip_concerns: true)
-        return enum_for(:each, root, kind: kind, skip_concerns: skip_concerns) unless block_given?
+      # `kind: :models` reads model_paths: what model_details lists, not only app/models.
+      def each(root, kind:, skip_concerns: true, base_model: nil, &block)
+        return enum_for(:each, root, kind: kind, skip_concerns: skip_concerns, base_model: base_model) unless block
 
-        paths(root, kind: kind, skip_concerns: skip_concerns) do |record|
+        read = lambda do |record|
           source = SafeFile.read(record.path) or next
-          yield record.with(source: source)
+          block.call(record.with(source: source))
         end
+        return paths(root, kind: kind, skip_concerns: skip_concerns, &read) unless kind == :models
+
+        model_paths(root, base_model: base_model) { |record| read.call(record) unless skip_concerns && record.path_name.start_with?("Concerns::") }
       end
 
       # The eager form: reads and parses every file for its declared name.
       # A caller that names only some files resolves DeclaredConstant itself.
-      def classes(root, kind:)
-        each(root, kind: kind).filter_map do |record|
-          next unless DeclaredConstant.declares_class?(record.source)
+      def classes(root, kind:, base_model: nil)
+        each(root, kind: kind, base_model: base_model).filter_map do |record|
+          next unless DeclaredConstant.declares_class?(record.source, path_name: record.path_name)
 
           [ DeclaredConstant.resolve(record.source, record.path_name), record ]
         end
@@ -74,16 +220,18 @@ module RailsAiContext
       # to a real path the root does not contain; the unresolved path is
       # still the one the app spells.
       def relative_file(path, real, root, real_root)
-        real_prefix = real_root + File::SEPARATOR
+        real_prefix = SafePath.dir_prefix(real_root)
         return real.delete_prefix(real_prefix) if real.start_with?(real_prefix)
 
-        path.delete_prefix(root + File::SEPARATOR)
+        path.delete_prefix(SafePath.dir_prefix(root))
       end
 
-      # Whether either spelling of a path lands inside either spelling of the
-      # root. Only one of the two holds for a symlinked pack.
+      # Either spelling may land inside the root (only one does for a symlinked
+      # pack), but a spelled ".." can climb out through a symlink, so it needs the real one.
       def under_root?(path, real, root, real_root)
-        path.start_with?(root + File::SEPARATOR) || real.start_with?(real_root + File::SEPARATOR)
+        return true if SafePath.contained?(real, real_root)
+
+        !path.split(File::SEPARATOR).include?("..") && File.expand_path(path).start_with?(SafePath.dir_prefix(root))
       end
     end
   end

data/lib/rails_ai_context/introspectors/sqlite_virtual_tables.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # Rails 8 leaves a virtual table and its shadow tables out of connection.tables;
+    # Rails 7.x lists them as plain tables and has no virtual_tables, so both are read here.
+    module SqliteVirtualTables
+      module_function
+
+      # Each virtual table's [module, arguments], read from sqlite_master as Rails 8 does.
+      def of(connection)
+        connection.select_rows("SELECT name, sql FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL %'").to_h do |name, sql|
+          [ name, sql.match(/USING\s+(\w+)\s*(?:\((.*)\))?/im).to_a.drop(1) ]
+        end
+      end
+
+      # ponytail: pragma_table_list needs SQLite 3.37+; an older SQLite under Rails 7.x still lists shadow tables.
+      def hidden(connection)
+        virtual = of(connection).keys
+        return virtual if virtual.empty?
+
+        virtual + connection.select_values("SELECT name FROM pragma_table_list WHERE type = 'shadow'")
+      rescue ActiveRecord::StatementInvalid
+        virtual
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/stimulus_introspector.rb

@@ -144,7 +144,7 @@ module RailsAiContext
         # the rails-new home an app's own loader can strip a segment the path keeps.
         def identifier_for(path, js_root)
           parts = path.sub("#{js_root}/", "").split("/")
-          index = parts.rindex("controllers")
+          index = parts.index("controllers")
           stem = (index ? parts[(index + 1)..] : parts).join("/")
                    .sub(/(?:_controller|\.controller)\.\w+\z/, "")
           [ stem.gsub("/", "--").tr("_", "-"), !default_home?(path, js_root) ]
@@ -159,7 +159,7 @@ module RailsAiContext
         # controller left without a free name is qualified by its code root and marked a guess.
         def resolve_names(paths, referenced, registered = {}, root: nil, loader_dirs: [])
           derived = paths.map { |path, js_root| [ path, js_root, identifier_for(path, js_root) ] }
-                         .sort_by { |path, js_root, _| [ js_root.count("/"), path ] }
+                         .sort_by { |path, js_root, (_name, guess)| [ code_root_of(js_root).count("/"), guess ? 1 : 0, path ] }
           claimed = derived.map { |_path, _js_root, (name, _guess)| name }.to_set
           taken = Set.new
           resolved = {}
@@ -238,7 +238,7 @@ module RailsAiContext
 
         def controllers_home(path, js_root)
           parts = path.delete_prefix("#{js_root}/").split("/")
-          index = parts.rindex("controllers") or return nil
+          index = parts.index("controllers") or return nil
           File.join(js_root, *parts.first(index + 1))
         end
 
@@ -255,11 +255,20 @@ module RailsAiContext
           end
         end
 
+        def js_dir_of(js_root)
+          JS_ROOTS.find { |dir| js_root == dir || js_root.end_with?("/#{dir}") }
+        end
+
+        # The code root a JS root belongs to: `frontend` and `app/javascript` share one.
+        def code_root_of(js_root)
+          js_root.delete_suffix(js_dir_of(js_root).to_s).chomp("/")
+        end
+
         # Names for a controller whose derived one is taken: prefixed by more and more
         # of its code root (`chat--foo`, `plugins--chat--foo`), then the whole path.
         def qualified_names(name, js_root, root)
           relative = root ? js_root.delete_prefix("#{root}/") : js_root
-          js_dir = JS_ROOTS.find { |dir| relative == dir || relative.end_with?("/#{dir}") }
+          js_dir = js_dir_of(relative)
           segments = (js_dir ? relative.delete_suffix(js_dir).chomp("/") : relative).split("/").reject(&:empty?)
           segments = [ js_dir.tr("/", "-") ] if segments.empty? && js_dir
           (1..segments.size).map { |n| "#{segments.last(n).join('--')}--#{name}" } +
@@ -300,7 +309,9 @@ module RailsAiContext
         # Every template or Ruby file an identifier can be written in: the one
         # file set that naming and the "used in" lookup both read.
         def template_files(root)
-          TEMPLATE_KINDS.flat_map { |kind| PathResolver.dirs_for(root, kind) }.uniq.flat_map { |dir|
+          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
           }.uniq
         end