rails-ai-context 5.32.2 → 5.34.0

data/lib/rails_ai_context/tools/get_schema.rb

@@ -109,11 +109,12 @@ module RailsAiContext
             else
               return json_response(table_data.except(:unread_calls).merge({ database: database }.compact)) if format == "json"
 
-              output = format_table_markdown(table_key, table_data, models_data, schema[:enum_types], schema[:search_path], listed_as: listed_as)
+              output = format_table_markdown(table_key, table_data, models_data, schema[:enum_types], schema[:search_path],
+                                             listed_as: listed_as, schema: schema, database: (databases.first if databases.size == 1))
               output = output.sub("\n\n", "\n\n**Database:** #{database}\n") if database
             end
             # Cross-reference hint for AI: suggest next tool call
-            model_refs = models_for_table([ table_key, listed_as ], models_data)
+            model_refs = models_for_table([ table_key, listed_as ], models_data, schema: schema, database: (databases.first if databases.size == 1))
             if model_refs.any?
               output += "\n\n_Next: `rails_get_model_details(model:\"#{model_refs.first}\")` for associations, validations, scopes._"
             end
@@ -139,7 +140,7 @@ module RailsAiContext
               idx_count = data[:indexes]&.size || 0
               lines << "- **#{name}**#{relation_suffix(data)} - #{count_phrase(col_count, "column")}, #{count_phrase(idx_count, "index", plural: "indexes")}"
             end
-            coverage = model_coverage_lines(tables, models_data)
+            coverage = model_coverage_lines(tables, models_data, schema)
             lines.concat([ "" ] + coverage) if coverage.any?
             lines.concat(secondary_databases_lines(schema))
             if page[:offset] + page[:limit] < total
@@ -150,7 +151,7 @@ module RailsAiContext
 
           when "standard"
             # Sort by column count (most complex first) - AI agents care about big tables first
-            sorted = tables.keys.sort_by { |name| -(tables[name][:columns]&.size || 0) }
+            sorted = tables.keys.sort_by.with_index { |name, i| [ -(tables[name][:columns]&.size || 0), i ] }
             page = paginate(sorted, offset: offset, limit: limit, default_limit: 25)
             paginated = page[:items]
             return json_page_response(schema, tables, paginated, models_data) if format == "json"
@@ -195,7 +196,7 @@ module RailsAiContext
 
               # Detect encrypted columns from model data
               encrypted_cols = Set.new
-              model_refs = models_for_table(name, models_data)
+              model_refs = models_for_table(name, models_data, schema: schema, database: "primary")
               model_refs.each do |model_name|
                 (models_data.dig(model_name, :encrypts) || []).each { |f| encrypted_cols.add(f) }
               end
@@ -215,13 +216,17 @@ module RailsAiContext
                     trailing.fetch(c[:name], []).uniq.each { |before| hints << "in index after #{before.join(', ')}" }
                   end
                   hints << "encrypted" if encrypted_cols.include?(c[:name])
+                  # The database computes a generated column, so a write to it fails.
+                  hints << (c[:stored] ? "generated, stored" : "generated") if c.key?(:generated)
                   # Show default value if present
                   if c.key?(:default) && !c[:default].nil? && c[:default] != ""
                     hints << "default: #{c[:default]}"
                   end
                   # A clause can hold a column list, so clauses part with a semicolon.
                   hint_str = hints.any? ? " [#{hints.join('; ')}]" : ""
-                  "#{[ c[:name], c[:type] ].compact.join(':')}#{hint_str}"
+                  # An array column reads `string[]`, as the table view writes it.
+                  type = c[:type] && c[:array] ? "#{c[:type]}[]" : c[:type]
+                  "#{[ c[:name], type ].compact.join(':')}#{hint_str}"
                 end.join(", ")
               # Inline model info so AI doesn't need a separate get_model_details call
               # Every model on the table, richest first: an STI child or a
@@ -247,9 +252,12 @@ module RailsAiContext
               lines << ""
             end
 
-            coverage = model_coverage_lines(tables, models_data)
+            coverage = model_coverage_lines(tables, models_data, schema)
             lines.concat(coverage + [ "" ]) if coverage.any?
             lines.concat(secondary_databases_lines(schema))
+            if page[:offset] + page[:limit] < total
+              lines << "_Showing #{paginated.size} of #{total}. Use `offset:#{page[:offset] + page[:limit]}` for more._"
+            end
             lines << "_Use `detail:\"summary\"` for all #{Introspectors::SchemaConventions.relations_phrase(tables)}, `detail:\"full\"` for indexes/FKs, or `table:\"name\"` for one table._" if total > page[:limit]
             text_response(lines.join("\n"))
 
@@ -265,10 +273,10 @@ module RailsAiContext
             lines = [ "# Schema Full Detail (#{paginated.size} of #{Introspectors::SchemaConventions.relations_phrase(tables)})", "" ]
             lines.concat(note_lines(schema))
             paginated.each do |name|
-              lines << format_table_markdown(name, tables[name], models_data, schema[:enum_types], schema[:search_path])
+              lines << format_table_markdown(name, tables[name], models_data, schema[:enum_types], schema[:search_path], schema: schema, database: "primary")
               lines << ""
             end
-            coverage = model_coverage_lines(tables, models_data)
+            coverage = model_coverage_lines(tables, models_data, schema)
             lines.concat(coverage + [ "" ]) if coverage.any?
             lines.concat(secondary_databases_lines(schema))
             if page[:offset] + page[:limit] < total
@@ -343,8 +351,14 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, Set.new, label: "declared_join_tables")
       end
 
-      private_class_method def self.models_for_table(table_names, models)
-        models.select { |_, d| d.is_a?(Hash) && Array(table_names).compact.include?(d[:table_name]) }.keys
+      # A table name is not a table: in a multi-database app the primary's
+      # `settings` and analytics' `settings` are two, and a model reads the one
+      # its database holds. `database` keeps the models that read that one.
+      private_class_method def self.models_for_table(table_names, models, schema: nil, database: nil)
+        models.select do |_, d|
+          d.is_a?(Hash) && Array(table_names).compact.include?(d[:table_name]) &&
+            (database.nil? || Payload.model_databases(schema, d).include?(database))
+        end.keys
       rescue => e
         RailsAiContext.debug_fail(e, [], label: "models_for_table")
       end
@@ -383,6 +397,11 @@ module RailsAiContext
         lines
       end
 
+      # The dump a static parse read, from its own note when nothing else names it.
+      private_class_method def self.dump_name(schema)
+        schema[:declared_in] || schema[:note].to_s[/\AParsed from (\S+)/, 1] || "db/schema.rb"
+      end
+
       private_class_method def self.static_source_lines(schema)
         lines = note_lines(schema)
         lines << "**Dialect:** #{schema[:dialect]}" if schema[:dialect] && schema[:dialect] != "unknown"
@@ -398,7 +417,14 @@ module RailsAiContext
                    "#{connected_total}. Missing: #{missing.sort.first(5).join(', ')}" \
                    "#{missing.size > 5 ? " (+#{missing.size - 5} more)" : ""}. Run `rails db:migrate`._"
         end
-        if schema[:pending_migrations].is_a?(Array)
+        # A database that holds none of the tables the dump lists is created
+        # but not migrated, and the listing above is the dump's.
+        if schema[:connected_tables]&.zero? && (declared_total = Introspectors::SchemaConventions.table_count(schema[:tables] || {})).positive?
+          lines << "_#{dump_name(schema)} declares #{count_phrase(declared_total, "table")}; the connected database has none of them. Run `rails db:migrate`._"
+        end
+        if schema[:pending_unknown]
+          lines << "**Pending migrations:** not known: #{schema[:pending_unknown]}"
+        elsif schema[:pending_migrations].is_a?(Array)
           pending = schema[:pending_migrations]
           if pending.any?
             lines << "**Pending migrations:** #{pending_phrase(pending)}"
@@ -437,7 +463,7 @@ module RailsAiContext
       private_class_method def self.json_page_response(schema, tables, names, models = {})
         # unread_calls is the static reader's note to validate; the booted tier has none.
         page = names.to_h { |name| [ name, tables[name].is_a?(Hash) ? tables[name].except(:unread_calls) : tables[name] ] }
-        coverage = model_coverage(tables, models)
+        coverage = model_coverage(tables, models, schema)
         json_response(schema.merge(tables: page, gem_owned_tables: coverage[:gems], tables_without_model_file: coverage[:unclaimed]))
       end
 
@@ -445,9 +471,11 @@ module RailsAiContext
 
       # Over every table, not the page: which ones no model file claims, and
       # of those, which a gem the app bundles owns.
-      private_class_method def self.model_coverage(tables, models)
+      private_class_method def self.model_coverage(tables, models, schema = nil)
         # A view or virtual table often has no model and is still read, so only tables count.
-        unclaimed = tables.keys.sort.select { |name| !tables[name][:kind] && models_for_table(name, models).empty? } - habtm_join_tables(models).to_a
+        database = ("primary" if schema)
+        unclaimed = tables.keys.sort.select { |name| !tables[name][:kind] && models_for_table(name, models, schema: schema, database: database).empty? } -
+                    habtm_join_tables(models).to_a
         unclaimed -= declared_join_tables(models).to_a if unclaimed.any?
         # A file the walk could not read claims no table, but it is still a model file.
         unclaimed -= models.filter_map { |_, d| d[:table_name] || Introspectors::TableName.stem(d[:file]) if d.is_a?(Hash) && d[:error] && d[:file] }
@@ -455,8 +483,8 @@ module RailsAiContext
         { gems: gems, unclaimed: unclaimed - gems.values.flatten }
       end
 
-      private_class_method def self.model_coverage_lines(tables, models)
-        coverage = model_coverage(tables, models)
+      private_class_method def self.model_coverage_lines(tables, models, schema = nil)
+        coverage = model_coverage(tables, models, schema)
         lines = coverage[:gems].map { |gem, owned| "Tables the #{gem} gem owns: #{capped(owned)}" }
         unclaimed = coverage[:unclaimed]
         if unclaimed.any?
@@ -526,14 +554,19 @@ module RailsAiContext
       end
 
       # listed_as: the listing's name for a table asked for by its qualified name.
-      private_class_method def self.format_table_markdown(name, data, models, enum_types = nil, search_path = nil, listed_as: nil)
+      private_class_method def self.format_table_markdown(name, data, models, enum_types = nil, search_path = nil, listed_as: nil, schema: nil, database: nil)
         columns = data[:columns] || []
         # Always show Nullable and Default - agents need these for migrations and validations
         has_defaults = columns.any? { |c| c.key?(:default) && !c[:default].nil? }
 
-        model_refs = models_for_table([ name, listed_as ], models)
+        model_refs = models_for_table([ name, listed_as ], models, schema: schema, database: database)
         lines = [ "## #{RELATION_KINDS.fetch(data[:kind].to_s, "Table")}: #{name}", "" ]
         lines << "**Models:** #{model_refs.join(', ')}" if model_refs.any?
+        # The listing marks these [encrypted]; a column the database holds as
+        # ciphertext reads differently from what the model hands back.
+        column_names = columns.map { |c| c[:name].to_s }
+        encrypted = model_refs.flat_map { |m| Array(models.dig(m, :encrypts)).map(&:to_s) }.uniq & column_names
+        lines << "**Encrypted:** #{encrypted.map { |c| "`#{c}`" }.join(', ')} (`encrypts`: ciphertext in the database)" if encrypted.any?
         lines << "**Module:** #{data[:module]}" if data[:module]
         lines << "**Primary key:** #{RailsAiContext::Introspectors::SchemaConventions.primary_key_label(data[:primary_key])}" if data[:primary_key]
         lines << "**Comment:** #{data[:comment]}" if data[:comment]

data/lib/rails_ai_context/tools/get_service_pattern.rb

@@ -597,34 +597,48 @@ module RailsAiContext
       end
 
       private_class_method def self.find_callers(class_name, real_root, own_file = nil)
-        callers = Set.new
-        search_dirs = caller_search_dirs(real_root)
+        callers, truncated = callers_of({ class_name => own_file }, real_root)
+        [ callers[class_name], truncated ]
+      end
+
+      # The files that name each service, from one pass over the tree:
+      # analyze_feature asks for every service a feature matched at once. The
+      # services' own files are not read.
+      #
+      # @param services [Hash{String => String, nil}] class name => the file defining it
+      # @return [Array(Hash{String => Array<String>}, Boolean)] the callers of each, by path,
+      #   and whether the scan stopped at MAX_CALLER_SCAN_FILES
+      def self.callers_of(services, real_root)
         # A bare `include?` matched `Billing::Invoices::Create` inside
         # `Workers::Billing::Invoices::CreateReminderWorker`, and the
         # underscored-path skip dropped the one real caller, whose path
         # contains the service's own path as a prefix.
-        reference = /(?<![\w:])(?:::)?#{Regexp.escape(class_name)}(?![\w:])/
+        references = services.keys.to_h { |name| [ name, /(?<![\w:])(?:::)?#{Regexp.escape(name)}(?![\w:])/ ] }
         # A second file declaring the same short name under its own namespace
         # is not a caller of this one, so the declaration is not a reference.
-        definition = /\b(?:class|module)\s+(?:::)?#{Regexp.escape(class_name)}(?![\w:])/
+        definitions = services.keys.to_h { |name| [ name, /\b(?:class|module)\s+(?:::)?#{Regexp.escape(name)}(?![\w:])/ ] }
 
         # The paths first, so the ceiling is measured against the files there
         # are rather than the files read: a tree of exactly the cap skips
         # nothing and must not say it stopped.
-        paths = search_dirs.flat_map { |dir| safe_glob(dir, "**/*.rb", real_root) }.uniq
-        paths.reject! { |real| real == own_file } if own_file
+        paths = caller_search_dirs(real_root).flat_map { |dir| safe_glob(dir, "**/*.rb", real_root) }.uniq
+        paths -= services.values.compact
         truncated = paths.size > MAX_CALLER_SCAN_FILES
 
+        callers = services.keys.to_h { |name| [ name, [] ] }
         paths.first(MAX_CALLER_SCAN_FILES).each do |real|
           source = safe_read(real)
           next unless source
-          next unless source.match?(reference)
-          next unless source.gsub(definition, "").match?(reference)
 
-          callers << real.sub("#{real_root}/", "")
+          references.each do |name, reference|
+            next unless source.match?(reference)
+            next unless source.gsub(definitions[name], "").match?(reference)
+
+            callers[name] << real.sub("#{real_root}/", "")
+          end
         end
 
-        [ callers.to_a.sort, truncated ]
+        [ callers.transform_values(&:sort), truncated ]
       end
 
       private_class_method def self.detect_common_pattern(stats)

data/lib/rails_ai_context/tools/get_stimulus.rb

@@ -258,13 +258,49 @@ module RailsAiContext
           attrs << "data-#{html_name}-#{kebab}-value=\"...\""
         end
 
+        # A class or an outlet the controller reads throws "Missing attribute"
+        # without its attribute, so the markup carries one for each.
+        (ctrl[:classes] || []).each do |name|
+          attrs << "data-#{html_name}-#{name.to_s.gsub(/([a-z\d])([A-Z])/, '\1-\2').downcase}-class=\"...\""
+        end
+        (ctrl[:outlets] || []).each do |name|
+          attrs << "data-#{html_name}-#{name}-outlet=\"...\""
+        end
+
+        used = view_action_events(html_name)
+        own_calls = Array(ctrl[:self_calls])
         (ctrl[:actions] || []).each do |a|
-          attrs << "data-action=\"click->#{html_name}##{a}\""
+          events = used[a]
+          if events
+            # The event the app's own markup wires the action to: a text field's
+            # `input->`, not the `click->` every action used to get.
+            events.each { |event| attrs << "data-action=\"#{"#{event}->" if event}#{html_name}##{a}\"" }
+          elsif !own_calls.include?(a)
+            # No event names the element's default one: click for a button,
+            # input for a text field, submit for a form.
+            attrs << "data-action=\"#{html_name}##{a}\""
+          end
+          # A method no markup names and the controller calls itself is a helper, not an action.
         end
 
         attrs
       end
 
+      # {action => the events the app's templates wire it to, nil for the
+      # element's default}, for one controller.
+      private_class_method def self.view_action_events(html_name)
+        root = rails_app.root.to_s
+        descriptor = /(?:([\w:.@+-]+)->)?(?<![\w-])#{Regexp.escape(html_name)}#(\w+)/
+        Introspectors::StimulusIntrospector.template_files(root).each_with_object({}) do |path, found|
+          raw = RailsAiContext::SafeFile.read(path) or next
+          next unless raw.include?("#{html_name}#")
+
+          raw.scan(descriptor) { |event, action| (found[action] ||= []) << event unless Array(found[action]).include?(event) }
+        end
+      rescue => e
+        RailsAiContext.debug_fail(e, {}, label: "view_action_events")
+      end
+
       # Views are named by their path under their views root, anything else from the app root.
       private_class_method def self.find_views_using(controller_name)
         root = rails_app.root.to_s

data/lib/rails_ai_context/tools/get_test_info.rb

@@ -230,6 +230,10 @@ module RailsAiContext
         refused = refuse_unsafe_paths([ name ])
         return refused if refused
 
+        # Longer than any file name, so no test file carries it, and each
+        # searched path it was put in echoed it whole: a 600 KB answer.
+        return empty_response("No test file found for #{echo_input(name)}.") if name_too_long?(name)
+
         candidates = RailsAiContext::TestFramework.candidates(suite_root, type, snake, cached_context)
         exercising = type == :controller ? exercising_tests(snake, candidates) : []
 
@@ -246,7 +250,7 @@ module RailsAiContext
             listed = examples(content)
             "# #{shown(rel)} (#{count_phrase(listed.size, "test")})\n\n#{listed.join("\n")}"
           else
-            "# #{shown(rel)}\n\n```ruby\n#{content}\n```"
+            "# #{shown(rel)}\n\n```ruby\n#{RailsAiContext::Redaction.redact_source(content, path: rel)}\n```"
           end
           return text_response(answer + exercising_section(exercising, "## Also exercised by"))
         end
@@ -264,7 +268,7 @@ module RailsAiContext
         # A refused candidate was never read, so listing it reads as a search
         # that happened. When every one was refused, the name is the answer.
         if contained.empty?
-          return error_response("No test file found for #{name}: the name was refused, it leaves the app root " \
+          return error_response("Path not allowed: the test file for #{name} leaves the app root " \
                                 "or names a sensitive file.")
         end
 
@@ -402,7 +406,17 @@ module RailsAiContext
           lines << ""
           lines << "RSpec.describe ModelName, type: :model do"
           lines << "  describe \"validations\" do"
-          lines << "    it { is_expected.to validate_presence_of(:field) }"
+          # validate_presence_of is shoulda-matchers', a NoMethodError in an
+          # app that does not bundle it; rails_generate_test asks the same.
+          if RailsAiContext::GemLock.for(rails_app.root.to_s).present?("shoulda-matchers")
+            lines << "    it { is_expected.to validate_presence_of(:field) }"
+          else
+            lines << "    it \"requires field\" do"
+            lines << "      record = ModelName.new"
+            lines << "      expect(record).not_to be_valid"
+            lines << "      expect(record.errors[:field]).to include(\"can't be blank\")"
+            lines << "    end"
+          end
           lines << "  end"
           lines << ""
           lines << "  describe \"#method_name\" do"
@@ -628,7 +642,7 @@ module RailsAiContext
 
         relationships
       rescue => e
-        {}
+        RailsAiContext.debug_fail(e, {}, label: "extract_fixture_relationships")
       end
     end
   end