rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/tools/get_schema.rb

@@ -65,10 +65,12 @@ module RailsAiContext
             # "Post" and "Admin::ActionLog" are model names here, and the model
             # tier knows the table each of them reads.
             table_as_table = RailsAiContext::Introspectors::TableName.for_model_name(table, models_data)
-            table_key = tables.keys.find { |k|
+            _, table_key, table_data = Payload.schema_tables(schema).find { |_, k, _|
               k.downcase == table_down || k == table_as_table || k == table.underscore
-            } || table
-            table_data = tables[table_key]
+            }
+            databases = table_data ? Payload.schema_databases(schema, table_key) : []
+            database = databases.join(", ") unless databases == [ "primary" ]
+            table_key ||= table
             unless table_data
               # A table db/schema.rb declares and the connection does not have
               # is not a misspelling: the migration that adds it has not run
@@ -80,18 +82,35 @@ module RailsAiContext
               declared = table_key.to_s.underscore
               if declared_not_connected(schema).include?(declared)
                 return text_response(
-                  "Table '#{declared}' is declared in db/schema.rb and missing from the connected database. " \
+                  "Table '#{declared}' is declared in #{schema[:declared_in] || "db/schema.rb"} and missing from the connected database. " \
                   "#{pending_for_table(schema, declared)}" \
                   "Run `rails db:migrate`, or pass `--no-boot` to read the declaration instead."
                 )
               end
 
-              return not_found_response("Table", table, tables.keys.sort,
-                recovery_tool: "Call rails_get_schema(detail:\"summary\") to see all tables")
+              recovery = "Call rails_get_schema(detail:\"summary\") to see all tables"
+              # Rails' own schema.rb dumper writes no view; only a gem such as scenic adds them.
+              if [ schema[:adapter], schema[:adapter_source] ].include?("static_parse")
+                recovery += ". Without a connection a view is listed only when the dump records it: structure.sql does, schema.rb only through a gem such as scenic"
+              end
+              return not_found_response("Table", table, Payload.schema_tables(schema).map { |_, name, _| name }.uniq.sort, recovery_tool: recovery)
+            end
+            # Databases holding the same table read as one; ones that differ each show their own.
+            groups = Payload.schema_tables(schema).select { |_, name, _| name == table_key }
+              .group_by { |_, _, data| data }.map { |data, rows| [ rows.map { |db, _, _| db || "primary" }, data ] }
+            if groups.size > 1
+              return json_response(table: table_key, databases: groups.flat_map { |dbs, data| dbs.map { |db| [ db, data.except(:unread_calls) ] } }.to_h) if format == "json"
+
+              output = groups.map do |dbs, data|
+                in_db = models_data.select { |_, model| model.is_a?(Hash) && model[:table_name] == table_key && Payload.model_databases(schema, model).intersect?(dbs) }
+                format_table_markdown(table_key, data, in_db, schema[:enum_types]).sub("\n\n", "\n\n**Database:** #{dbs.join(", ")}\n")
+              end.join("\n\n")
+            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])
+              output = output.sub("\n\n", "\n\n**Database:** #{database}\n") if database
             end
-            return json_response(table_data.except(:unread_calls)) if format == "json"
-
-            output = format_table_markdown(table_key, table_data, models_data)
             # Cross-reference hint for AI: suggest next tool call
             model_refs = models_for_table(table_key, models_data)
             if model_refs.any?
@@ -110,14 +129,14 @@ module RailsAiContext
               return text_response("No tables at offset #{page[:offset]}. Total: #{total}. Use `offset:0` to start over.")
             end
 
-            lines = [ "# Schema Summary (#{count_phrase(total, "table")})", "" ]
+            lines = [ "# Schema Summary (#{Introspectors::SchemaConventions.relations_phrase(tables)})", "" ]
             lines << "**Adapter:** #{adapter_label(ctx)}" if schema[:adapter]
             lines.concat(static_source_lines(schema))
             paginated.each do |name|
               data = tables[name]
               col_count = data[:columns]&.size || 0
               idx_count = data[:indexes]&.size || 0
-              lines << "- **#{name}** - #{count_phrase(col_count, "column")}, #{count_phrase(idx_count, "index", plural: "indexes")}"
+              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)
             lines.concat([ "" ] + coverage) if coverage.any?
@@ -135,11 +154,11 @@ module RailsAiContext
             paginated = page[:items]
             return json_page_response(schema, tables, paginated, models_data) if format == "json"
 
-            if paginated.empty?
+            if paginated.empty? && total > 0
               return text_response("No tables at offset #{page[:offset]}. Total tables: #{total}. Use `offset:0` to start from the beginning.")
             end
 
-            lines = [ "# Schema (#{count_phrase(total, "table")}, showing #{paginated.size})", "" ]
+            lines = [ "# Schema (#{Introspectors::SchemaConventions.relations_phrase(tables)}, showing #{paginated.size})", "" ]
             lines.concat(static_source_lines(schema))
             paginated.each do |name|
               data = tables[name]
@@ -201,7 +220,7 @@ module RailsAiContext
                   end
                   # A clause can hold a column list, so clauses part with a semicolon.
                   hint_str = hints.any? ? " [#{hints.join('; ')}]" : ""
-                  "#{c[:name]}:#{c[:type]}#{hint_str}"
+                  "#{[ c[:name], c[: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
@@ -221,15 +240,16 @@ module RailsAiContext
               else
                 ""
               end
-              lines << "### #{name}#{model_info}"
-              lines << cols
+              key = data[:primary_key] && data[:primary_key] != "id" ? " (primary key: #{RailsAiContext::Introspectors::SchemaConventions.primary_key_label(data[:primary_key])})" : ""
+              lines << "### #{name}#{key}#{relation_suffix(data)}#{model_info}"
+              lines << cols unless cols.empty? && data[:columns].blank?
               lines << ""
             end
 
             coverage = model_coverage_lines(tables, models_data)
             lines.concat(coverage + [ "" ]) if coverage.any?
             lines.concat(secondary_databases_lines(schema))
-            lines << "_Use `detail:\"summary\"` for all #{count_phrase(total, "table")}, `detail:\"full\"` for indexes/FKs, or `table:\"name\"` for one table._" if total > page[:limit]
+            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"))
 
           when "full"
@@ -241,10 +261,10 @@ module RailsAiContext
               return text_response("No tables at offset #{page[:offset]}. Total: #{total}. Use `offset:0` to start over.")
             end
 
-            lines = [ "# Schema Full Detail (#{paginated.size} of #{count_phrase(total, "table")})", "" ]
+            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)
+              lines << format_table_markdown(name, tables[name], models_data, schema[:enum_types])
               lines << ""
             end
             coverage = model_coverage_lines(tables, models_data)
@@ -355,12 +375,14 @@ module RailsAiContext
       # schema version recorded by the dump, and migration files it doesn't
       # cover - the static-tier stand-ins for a live connection's answers.
       private_class_method def self.note_lines(schema)
-        schema[:note].to_s.empty? ? [] : [ "_#{schema[:note]}_" ]
+        lines = schema[:note].to_s.empty? ? [] : [ "_#{schema[:note]}_" ]
+        lines << "**Extensions:** #{schema[:extensions].join(', ')}" if schema[:extensions]&.any?
+        lines
       end
 
       private_class_method def self.static_source_lines(schema)
         lines = note_lines(schema)
-        lines << "**Dialect:** #{schema[:dialect]} (db/structure.sql)" if schema[:dialect] && schema[:dialect] != "unknown"
+        lines << "**Dialect:** #{schema[:dialect]}" if schema[:dialect] && schema[:dialect] != "unknown"
         lines << "**Schema version:** #{schema[:schema_version]}" if schema[:schema_version]
         # The header pairs a live table count with the version stamp read off
         # db/schema.rb, and nothing joined the two: at that migration the app
@@ -368,16 +390,15 @@ module RailsAiContext
         missing = declared_not_connected(schema)
         if missing.any?
           declared_total = Array(schema[:declared_tables]).size
-          lines << "_db/schema.rb declares #{count_phrase(declared_total, "table")}; the connected database has " \
-                   "#{(schema[:tables] || {}).size}. Missing: #{missing.sort.first(5).join(', ')}" \
+          connected_total = Introspectors::SchemaConventions.table_count(schema[:tables] || {})
+          lines << "_#{schema[:declared_in] || "db/schema.rb"} declares #{count_phrase(declared_total, "table")}; the connected database has " \
+                   "#{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)
           pending = schema[:pending_migrations]
           if pending.any?
-            shown = pending.first(5).map { |m| m[:version] }.join(", ")
-            more = pending.size > 5 ? " (+#{pending.size - 5} more)" : ""
-            lines << "**Pending migrations:** #{pending.size} - #{shown}#{more}"
+            lines << "**Pending migrations:** #{pending_phrase(pending)}"
           elsif schema[:schema_version]
             lines << "**Pending migrations:** none"
           end
@@ -395,12 +416,18 @@ module RailsAiContext
 
         lines = [ "", "## Secondary databases", "" ]
         secondary.each do |name, db|
-          count = db[:total_tables]
-          lines << "- **#{name}**: #{count_phrase(count, "table")} (#{db[:tables].keys.join(', ')}) - #{db[:note]}"
+          pending = Array(db[:pending_migrations])
+          pending_text = pending.any? ? "; pending migrations: #{pending_phrase(pending)}" : ""
+          lines << "- **#{name}**: #{Introspectors::SchemaConventions.relations_phrase(db[:tables])} (#{db[:tables].keys.join(', ')}) - #{db[:note]}#{pending_text}"
         end
         lines
       end
 
+      private_class_method def self.pending_phrase(pending)
+        more = pending.size > 5 ? " (+#{pending.size - 5} more)" : ""
+        "#{pending.size} - #{pending.first(5).map { |m| m[:version] }.join(', ')}#{more}"
+      end
+
       # One JSON shape for every detail level: the schema as introspected,
       # with :tables cut down to the page the same pagination produced for
       # markdown. `detail` still decides how many tables a page holds.
@@ -416,7 +443,8 @@ 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)
-        unclaimed = tables.keys.sort.select { |name| models_for_table(name, models).empty? } - habtm_join_tables(models).to_a
+        # 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
         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] }
@@ -446,78 +474,149 @@ module RailsAiContext
         "#{names.first(COVERAGE_CAP).join(', ')}, and #{names.size - COVERAGE_CAP} more"
       end
 
-      private_class_method def self.format_table_markdown(name, data, models)
+      # The type as a migration declares it: `decimal(10,2)`, `string, limit: 20`.
+      private_class_method def self.column_type_label(col)
+        label = col[:type].to_s
+        sizes = [ col[:precision], col[:scale] ].compact
+        label += "(#{sizes.join(',')})" if col[:precision]
+        label += "[]" if col[:array]
+        label += ", limit: #{col[:limit]}" if col[:limit]
+        label += ", size: #{col[:size]}" if col[:size]
+        label += ", unsigned" if col[:unsigned]
+        label += ", collation: #{col[:collation]}" if col[:collation]
+        label += ", enum_type: #{col[:enum_type]}" if col[:enum_type]
+        label
+      end
+
+      # Options are joined by semicolons because a value can list columns.
+      private_class_method def self.index_options_text(idx)
+        parts = []
+        parts << "using: #{idx[:using]}" if idx[:using]
+        parts << "type: #{idx[:type]}" if idx[:type]
+        parts << "include: #{idx[:include].join(', ')}" if idx[:include]
+        %i[order opclass length].each do |key|
+          parts << "#{key}: #{idx[key].map { |column, value| "#{column} #{value}" }.join(', ')}" if idx[key]
+        end
+        parts << "nulls not distinct" if idx[:nulls_not_distinct]
+        parts.any? ? " - #{parts.join('; ')}" : ""
+      end
+
+      RELATION_KINDS = { "view" => "View", "materialized_view" => "Materialized view", "virtual_table" => "Virtual table" }.freeze
+
+      # What a listed name is when it is not a plain table.
+      private_class_method def self.relation_suffix(data)
+        label = case data[:kind]
+        when "virtual_table" then "#{data[:module]} virtual table".strip
+        when "view", "materialized_view" then RELATION_KINDS[data[:kind]].downcase
+        else "not dumped" if data[:not_dumped]
+        end
+        label ? " (#{label})" : ""
+      end
+
+      private_class_method def self.index_lines(data)
+        return [] unless data[:indexes]&.any?
+
+        [ "", "### Indexes" ] + data[:indexes].map do |idx|
+          unique = idx[:unique] ? " (unique)" : ""
+          "- `#{idx[:name]}` on (#{Array(idx[:columns]).join(', ')})#{unique}#{RailsAiContext::Introspectors::SchemaConventions.where_clause(idx[:where])}#{index_options_text(idx)}"
+        end
+      end
+
+      private_class_method def self.format_table_markdown(name, data, models, enum_types = 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, models)
-        lines = [ "## Table: #{name}", "" ]
+        lines = [ "## #{RELATION_KINDS.fetch(data[:kind].to_s, "Table")}: #{name}", "" ]
         lines << "**Models:** #{model_refs.join(', ')}" if model_refs.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]
+        if data[:not_dumped]
+          lines << "The schema dumper could not describe this table (#{data[:not_dumped]}), so the dump holds no columns for it."
+        elsif data[:sql] && columns.empty?
+          lines << "A view's columns are read from the database, and this answer has no connection: boot the app to list them."
+        end
+        # A table right after a paragraph line would read as part of it.
+        lines << "" if lines.size > 2
+        definition = data[:sql] ? [ "### Definition", "```sql", data[:sql], "```" ] : []
+        if columns.empty? && (data[:sql] || data[:not_dumped])
+          indexes = index_lines(data)
+          return lines.concat(indexes.any? ? indexes.drop(1) + [ "" ] : []).concat(definition).join("\n").rstrip
+        end
 
-        header = "| Column | Type | Null"
-        sep = "|--------|------|-----"
+        has_comments = columns.any? { |c| c[:comment] && !c[:comment].to_s.empty? }
+        # A virtual table's module, not a column type, decides what its columns hold.
+        typed = columns.any? { |c| c[:type] }
+        header = typed ? "| Column | Type | Null" : "| Column"
+        sep = typed ? "|--------|------|-----" : "|--------"
         header += " | Default" if has_defaults
         sep += "-|---------" if has_defaults
+        header += " | Comment" if has_comments
+        sep += "-|---------" if has_comments
         lines << "#{header} |" << "#{sep}|"
 
-        has_comments = columns.any? { |c| c[:comment] && !c[:comment].to_s.empty? }
-
         columns.each do |col|
           nullable = col.key?(:null) ? (col[:null] ? "yes" : "**NO**") : "yes"
-          col_type = col[:array] ? "#{col[:type]}[]" : col[:type].to_s
-          line = "| #{col[:name]} | #{col_type} | #{nullable}"
+          line = typed ? "| #{col[:name]} | #{column_type_label(col)} | #{nullable}" : "| #{col[:name]}"
           if has_defaults
             default_val = col[:default]
             display_default = default_val == "" ? '""' : default_val
             line += " | #{display_default}"
           end
+          line += " | #{col[:comment].to_s.gsub('|', '\\|').gsub(/\s*\n\s*/, ' ')}" if has_comments
           lines << "#{line} |"
-          lines << "  _#{col[:comment]}_" if has_comments && col[:comment] && !col[:comment].to_s.empty?
         end
+        if data[:inherits_unresolved]&.any?
+          parents = data[:inherits_unresolved].map { |parent| "`#{parent}`" }.join(", ")
+          lines << "" << "Inherits from #{parents}, which the structure.sql dump does not define: its columns are not shown."
+        end
+
+        lines.concat(index_lines(data))
 
-        if data[:indexes]&.any?
-          lines << "" << "### Indexes"
-          data[:indexes].each do |idx|
-            unique = idx[:unique] ? " (unique)" : ""
-            lines << "- `#{idx[:name]}` on (#{Array(idx[:columns]).join(', ')})#{unique}#{RailsAiContext::Introspectors::SchemaConventions.where_clause(idx[:where])}"
+        if data[:unique_constraints]&.any?
+          lines << "" << "### Unique constraints"
+          data[:unique_constraints].each do |constraint|
+            deferrable = constraint[:deferrable] ? ", deferrable: #{constraint[:deferrable]}" : ""
+            lines << "- `#{constraint[:name]}` on (#{Array(constraint[:columns]).join(', ')})#{deferrable}"
           end
         end
 
         if data[:foreign_keys]&.any?
           lines << "" << "### Foreign keys"
           data[:foreign_keys].each do |fk|
+            actions = fk.slice(:on_delete, :on_update, :deferrable, :validate).map { |key, value| "#{key}: #{value}" }
             lines << "- `#{RailsAiContext::Introspectors::SchemaConventions.key_text(fk[:column])}` → " \
-                     "`#{fk[:to_table]}.#{RailsAiContext::Introspectors::SchemaConventions.key_text(fk[:primary_key])}`"
+                     "`#{fk[:to_table]}.#{RailsAiContext::Introspectors::SchemaConventions.key_text(fk[:primary_key])}`" \
+                     "#{" (#{actions.join(', ')})" if actions.any?}"
           end
         end
 
-        # Check constraints (full detail)
         if data[:check_constraints]&.any?
-          lines << "" << "### Check Constraints"
-          data[:check_constraints].each do |cc|
-            label = cc[:name] ? "`#{cc[:name]}`" : ""
-            lines << "- #{label} #{cc[:expression]}"
+          lines << "" << "### Check constraints"
+          data[:check_constraints].each do |constraint|
+            lines << "- #{"`#{constraint[:name]}`: " if constraint[:name]}#{constraint[:expression]}"
           end
         end
 
-        # Enum types (full detail)
-        if data[:enum_types]&.any?
-          lines << "" << "### Enum Types"
-          data[:enum_types].each do |et|
-            values = et[:values]&.join(", ") || ""
-            lines << "- `#{et[:name]}`: #{values}"
-          end
+        used = columns.filter_map { |c| c[:enum_type] }
+        enums = Array(enum_types).select { |enum| used.include?(enum[:name]) }
+        if enums.any?
+          lines << "" << "### Enum types"
+          enums.each { |enum| lines << "- `#{enum[:name]}`: #{Array(enum[:values]).join(', ')}" }
         end
 
-        # Generated columns (full detail)
-        if data[:generated_columns]&.any?
-          lines << "" << "### Generated Columns"
-          data[:generated_columns].each do |gc|
-            lines << "- `#{gc[:name]}` - #{gc[:expression]}"
+        generated = columns.select { |c| c.key?(:generated) }
+        if generated.any?
+          lines << "" << "### Generated columns"
+          generated.each do |col|
+            expression = col[:generated].to_s.empty? ? "" : ": #{col[:generated]}"
+            lines << "- `#{col[:name]}`#{expression} (#{col[:stored] ? "stored" : "virtual"})"
           end
         end
 
+        lines.concat([ "" ] + definition) if definition.any?
         lines.join("\n")
       end
     end

data/lib/rails_ai_context/tools/get_service_pattern.rb

@@ -4,7 +4,7 @@ module RailsAiContext
   module Tools
     class GetServicePattern < BaseTool
       tool_name "rails_get_service_pattern"
-      description "Analyze service objects in app/services/: patterns, interfaces, dependencies, and side effects. " \
+      description "Analyze service objects in app/services/, app/interactions/ and app/interactors/: patterns, interfaces, dependencies, and side effects. " \
         "Use when: understanding how services are structured, adding a new service, or tracing what a service does. " \
         "Specify service:\"CreateOrder\" for full detail, or omit to detect the common pattern and list all services."
 
@@ -26,15 +26,17 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
+      SERVICE_ROOTS = Introspectors::ServiceClasses::ROOTS
+
       def self.call(service: nil, detail: "standard", server_context: nil)
         blank = blank_name_response("service", service)
         return blank if blank
 
         root = rails_app.root.to_s
-        service_dirs = PathResolver.dirs_for(root, "app/services")
+        service_dirs = SERVICE_ROOTS.flat_map { |kind| PathResolver.dirs_for(root, kind) }.uniq
 
         if service_dirs.empty?
-          searched = PathResolver.search_patterns(root, "app/services").map { |pattern| "#{pattern}/" }
+          searched = SERVICE_ROOTS.flat_map { |kind| PathResolver.search_patterns(root, kind) }.uniq.map { |pattern| "#{pattern}/" }
           return text_response("No services directory found. Searched #{searched.join(', ')}. " \
             "This app may not use the service objects pattern.")
         end
@@ -127,11 +129,20 @@ module RailsAiContext
           lines.concat(inputs)
         end
 
-        owned = owned_methods(source, constant_for(file, service_dirs))
+        owned, macros, steps = class_interface(source, constant_for(file, service_dirs))
+        built = macro_constructor(macros, record, lookup)
 
-        # Initialize params
-        init_params = extract_initialize_params(owned)
+        init_params = extract_initialize_params(owned) || built&.dig(:signature)
         lines << "**Initialize:** `#{init_params}`" if init_params
+        if built
+          lines << "" << "## Inputs (#{built[:library]})"
+          built[:inputs].each { |input| lines << "- #{input}" }
+        end
+
+        if steps.any?
+          lines << "" << "## Organizes"
+          steps.each_with_index { |step, index| lines << "#{index + 1}. `#{step}`" }
+        end
 
         # Public methods
         public_methods = extract_public_methods(owned)
@@ -193,10 +204,10 @@ module RailsAiContext
         return { path: file } unless source
         return if Introspectors::ServiceClasses.concern?(nil, source)
 
-        class_name, superclass = name_and_superclass(source, file, service_dirs)
+        class_name, superclass, nesting = name_and_superclass(source, file, service_dirs)
         return if Introspectors::ServiceClasses.mailer?(source, class_name, superclass, lookup)
 
-        { path: file, source: source, class_name: class_name, superclass: superclass,
+        { path: file, source: source, class_name: class_name, superclass: superclass, nesting: nesting,
           entryless: Introspectors::ServiceClasses.entryless_module?(source, class_name) }
       end
 
@@ -211,19 +222,22 @@ module RailsAiContext
       end
 
       private_class_method def self.format_service_listing(service_files, service_dirs, root, detail, lookup)
-        service_data = service_records(service_files, service_dirs, root, lookup).filter_map do |record|
-          next unless record[:source]
-
+        read = service_records(service_files, service_dirs, root, lookup).select { |record| record[:source] }.map do |record|
+          [ record, *class_interface(record[:source], constant_for(record[:path], service_dirs)) ]
+        end
+        # A listed parent's macros are already read, so its children's constructors reuse them.
+        walks = read.to_h { |record, _, macros| [ record[:class_name], { name: record[:class_name], superclass: record[:superclass], macros: macros } ] }
+        service_data = read.map do |record, owned, macros|
           file, source = record.values_at(:path, :source)
-          owned = owned_methods(source, constant_for(file, service_dirs))
 
           {
             file: file.sub("#{root}/", ""),
             class_name: record[:class_name],
             superclass: record[:superclass],
+            nesting: record[:nesting],
             line_count: source.lines.size,
             public_methods: extract_public_methods(owned),
-            init_params: extract_initialize_params(owned),
+            init_params: extract_initialize_params(owned) || macro_constructor(macros, record, lookup, walks)&.dig(:signature),
             class_method_call: owned.any? { |m| m[:scope] == :class && m[:name] == "call" },
             result_object: source.match?(/Result\.new|OpenStruct\.new|Struct\.new|\.success|\.failure/),
             active_interaction: Introspectors::Interaction.interaction?(source, lookup: lookup),
@@ -308,7 +322,7 @@ module RailsAiContext
       # A base class is not a service a caller invokes: counted as one it
       # inflates the total and the pattern denominator beside it.
       private_class_method def self.base_class_names(service_data)
-        Introspectors::ServiceClasses.abstract_names(service_data.map { |s| [ s[:class_name], s[:superclass] ] })
+        Introspectors::ServiceClasses.abstract_names(service_data.map { |s| s.values_at(:class_name, :superclass, :nesting) })
       end
 
       # The class this file declares and the superclass it names, from the one
@@ -379,18 +393,101 @@ module RailsAiContext
       # outermost definition in the file.
       #
       # One walk per file: the interface and the constructor have to resolve
-      # the same owner, and a second walk could pick a different one.
-      private_class_method def self.owned_methods(source, expected_constant = nil)
+      # the same owner, and a second walk could pick a different one. The
+      # constructor macros come from the same walk, outside any `def`.
+      private_class_method def self.class_interface(source, expected_constant = nil)
         ast = Introspectors::SourceIntrospector.walk_source(
-          source, { methods: -> { Introspectors::Listeners::MethodsListener.new(include_initialize: true) } }
+          source, { methods: -> { Introspectors::Listeners::MethodsListener.new(include_initialize: true) },
+                    macros: Introspectors::Listeners::ConstructorMacroListener,
+                    organize: -> { Introspectors::Listeners::GenericMacroListener.new(:organize) } }
         )
         methods = ast[:methods] || []
-        return [] if methods.empty?
-
-        owner = primary_owner(methods, expected_constant)
-        Introspectors::ActionResolver.own_methods(methods, owner)
+        macros = Introspectors::SourceIntrospector.outside_defs(ast[:macros], methods)
+        owners = (methods + macros).map { |m| Introspectors::ActionResolver.owner_name(m) }
+        # An organizer's steps, in the order interactor runs them.
+        steps = Introspectors::SourceIntrospector.outside_defs(ast[:organize], methods).flat_map { |m| Array(m[:values]) }
+          .flat_map { |value| Array(value) }.select { |value| value.is_a?(String) }
+        return [ [], [], steps ] if owners.empty?
+
+        owner = primary_owner(owners, expected_constant)
+        [ Introspectors::ActionResolver.own_methods(methods, owner),
+          macros.select { |m| Introspectors::ActionResolver.owner_name(m) == owner }, steps ]
       rescue => e
-        RailsAiContext.debug_fail(e, [], label: "owned_methods AST")
+        RailsAiContext.debug_fail(e, [ [], [], [] ], label: "class_interface AST")
+      end
+
+      T_STRUCT_BASES = %w[T::Struct T::ImmutableStruct T::InexactStruct].freeze
+      DRY_STRUCT_BASES = %w[Dry::Struct Dry::Struct::Value].freeze
+
+      # The constructor a library's macros define, kept only when the class is
+      # that library's: `attribute` is also ActiveModel's, `param` anybody's.
+      # Dry::Struct attributes and dry-initializer params and options add to the
+      # parent's, so the app's own superclasses contribute theirs, farthest first.
+      INHERITED_MACROS = %i[extend attribute attribute? param option].freeze
+
+      private_class_method def self.macro_constructor(macros, record, lookup, walks = {})
+        inherited = inherited_macros(record, lookup, walks).reverse.flat_map do |parent|
+          parent[:macros].select { |m| INHERITED_MACROS.include?(m[:macro]) }.map { |m| m.merge(from: parent[:name]) }
+        end
+        macros = inherited + macros
+        return nil if macros.empty?
+
+        dry_initializer = macros.any? { |m| m[:macro] == :extend && Array(m[:values]).include?("Dry::Initializer") }
+        library = ->(bases) { reaches?(record, bases, lookup) }
+        kept = macros.select do |m|
+          case m[:macro]
+          when :extend then false
+          when :const, :prop then library.call(T_STRUCT_BASES)
+          when :attribute, :attribute? then library.call(DRY_STRUCT_BASES)
+          when :param, :option then dry_initializer
+          else true
+          end
+        end
+        return nil if kept.empty?
+
+        kept = kept.partition { |m| m[:macro] != :option }.flatten if dry_initializer
+        names = { const: "T::Struct", prop: "T::Struct", attribute: "Dry::Struct", attribute?: "Dry::Struct",
+                  param: "dry-initializer", option: "dry-initializer" }
+        { library: kept.map { |m| names.fetch(m[:macro], "attr_extras") }.uniq.join(", "),
+          signature: "initialize(#{kept.flat_map { |m| m[:params] }.map { |param| param_text(param) }.join(', ')})",
+          inputs: kept.map { |m| m[:from] ? "`#{m[:source]}` (from `#{m[:from]}`)" : "`#{m[:source]}`" } }
+      end
+
+      # The app's own superclasses, nearest first, each with the constructor macros its body declares.
+      private_class_method def self.inherited_macros(record, lookup, walks)
+        chain = []
+        seen = [ record[:class_name] ]
+        parent = record[:superclass]
+        while parent && lookup && chain.size < Introspectors::SuperclassChain::MAX_DEPTH && !seen.include?(parent)
+          seen << parent
+          entry = walks[parent] ||= begin
+            source = lookup.call(parent)
+            declared = source && Introspectors::DeclaredConstant.declaration_named(Introspectors::DeclaredConstant.declarations(source, path_name: parent), parent)
+            declared ? { name: declared.name, superclass: declared.superclass, macros: class_interface(source, declared.name)[1] } : {}
+          end
+          break unless entry[:name]
+
+          chain << entry
+          parent = entry[:superclass]
+        end
+        chain
+      end
+
+      private_class_method def self.reaches?(record, bases, lookup)
+        return true if bases.include?(record[:superclass].to_s.delete_prefix("::"))
+        return false unless record[:superclass]
+
+        Introspectors::SuperclassChain.to(record[:source], bases: bases, lookup: lookup, only: record[:class_name]).any?
+      end
+
+      private_class_method def self.param_text(param)
+        kind, name, default = param
+        case kind
+        when :req then name
+        when :opt then "#{name} = #{default}"
+        when :keyreq then "#{name}:"
+        else "#{name}: #{default}"
+        end
       end
 
       # A service that defines no constructor answers `.new` with no arguments.
@@ -403,11 +500,10 @@ module RailsAiContext
       # interface, which is why it is dropped here rather than at the walk.
       private_class_method def self.extract_public_methods(owned)
         owned.select { |m| m[:visibility] == :public && m[:name] != "initialize" }
-             .map { |m| m[:signature] }
+             .map { |m| m[:scope] == :class && !m[:signature].start_with?("self.") ? "self.#{m[:signature]}" : m[:signature] }
       end
 
-      private_class_method def self.primary_owner(methods, expected_constant)
-        owners = methods.map { |m| Introspectors::ActionResolver.owner_name(m) }
+      private_class_method def self.primary_owner(owners, expected_constant)
         return expected_constant if expected_constant && owners.include?(expected_constant)
 
         owners.min_by { |o| [ o.count(":"), o.length ] }

data/lib/rails_ai_context/tools/get_stimulus.rb

@@ -278,7 +278,7 @@ module RailsAiContext
           raw = RailsAiContext::SafeFile.read(path) or next
           next unless Introspectors::StimulusIntrospector.identifiers_in(path, raw).include?(token)
 
-          dir = view_dirs.find { |d| path.start_with?("#{d}/") }
+          dir = RailsAiContext::ViewFile.root_for(path, view_dirs)
           dir ? [ path.delete_prefix("#{dir}/"), true ] : [ path.delete_prefix("#{root}/"), false ]
         rescue SystemCallError
           next