rails-ai-context 4.2.3 → 4.3.1

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -156,21 +156,33 @@ module RailsAiContext
         File.join(app.root, "db", "structure.sql")
       end
 
+      def migrations_dir
+        File.join(app.root, "db", "migrate")
+      end
+
       def max_schema_file_size
         RailsAiContext.configuration.max_schema_file_size
       end
 
       # Fallback: parse schema file as text when DB isn't connected.
-      # Tries db/schema.rb first, then db/structure.sql.
+      # Tries db/schema.rb first, then db/structure.sql, then migrations.
       # This enables introspection in CI, Claude Code, etc.
       def static_schema_parse
         if File.exist?(schema_file_path)
-          parse_schema_rb(schema_file_path)
-        elsif File.exist?(structure_file_path)
-          parse_structure_sql(structure_file_path)
-        else
-          { error: "No db/schema.rb or db/structure.sql found" }
+          result = parse_schema_rb(schema_file_path)
+          return result if result[:total_tables].to_i > 0
+        end
+
+        if File.exist?(structure_file_path)
+          result = parse_structure_sql(structure_file_path)
+          return result if result[:total_tables].to_i > 0
         end
+
+        if Dir.exist?(migrations_dir) && Dir.glob(File.join(migrations_dir, "*.rb")).any?
+          return parse_migrations
+        end
+
+        { error: "No db/schema.rb, db/structure.sql, or migrations found" }
       end
 
       def parse_schema_rb(path)
@@ -374,6 +386,171 @@ module RailsAiContext
         []
       end
 
+      # Reconstruct schema by replaying migrations in order.
+      # Handles: create_table, add_column, remove_column, rename_column,
+      # rename_table, drop_table, change_column, add_index, add_reference,
+      # add_foreign_key, add_timestamps.
+      def parse_migrations
+        tables = {}
+        migration_files = Dir.glob(File.join(migrations_dir, "*.rb")).sort
+
+        migration_files.each do |path|
+          content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+          replay_migration(content, tables)
+        rescue => e
+          next # Skip unparseable migrations
+        end
+
+        # Remove internal Rails tables
+        tables.delete("ar_internal_metadata")
+        tables.delete("schema_migrations")
+
+        {
+          adapter: "static_parse",
+          tables: tables,
+          total_tables: tables.size,
+          note: "Reconstructed from #{migration_files.size} migration files (no DB connection, no schema.rb)"
+        }
+      end
+
+      def replay_migration(content, tables) # rubocop:disable Metrics
+        current_table = nil
+
+        content.each_line do |line|
+          stripped = line.strip
+
+          # create_table :name / create_table "name"
+          if (match = stripped.match(/create_table\s+[:"'](\w+)/))
+            table_name = match[1]
+            current_table = table_name
+            tables[table_name] ||= { columns: [], indexes: [], foreign_keys: [] }
+            # create_table implicitly adds id and timestamps in some cases
+          elsif stripped.match?(/\A\s*end\b/) && current_table
+            current_table = nil
+
+          # t.references / t.belongs_to inside create_table (must be before general column match)
+          elsif current_table && (match = stripped.match(/t\.(?:references|belongs_to)\s+[:"'](\w+)/))
+            ref_name = match[1]
+            col = { name: "#{ref_name}_id", type: "bigint" }
+            col[:null] = false if stripped.include?("null: false")
+            tables[current_table][:columns] << col
+
+          # t.timestamps inside create_table
+          elsif current_table && stripped.match?(/t\.timestamps/)
+            tables[current_table][:columns] << { name: "created_at", type: "datetime", null: false }
+            tables[current_table][:columns] << { name: "updated_at", type: "datetime", null: false }
+
+          # t.index inside create_table
+          elsif current_table && (match = stripped.match(/t\.index\s+\[([^\]]*)\]/))
+            cols = match[1].scan(/[:"'](\w+)/).flatten
+            unique = stripped.include?("unique: true")
+            idx_name = stripped.match(/name:\s*[:"']([^"'\s,]+)/)&.send(:[], 1)
+            tables[current_table][:indexes] << { name: idx_name, columns: cols, unique: unique }.compact if cols.any?
+
+          # t.type :name / t.type "name" (general column match inside create_table block)
+          elsif current_table && (match = stripped.match(/t\.(\w+)\s+[:"'](\w+)/))
+            col_type = match[1]
+            col_name = match[2]
+            next if %w[index check_constraint].include?(col_type)
+            col = { name: col_name, type: col_type }
+            col[:null] = false if stripped.include?("null: false")
+            if (def_match = stripped.match(/default:\s*("[^"]*"|\d+(?:\.\d+)?|true|false)/))
+              raw = def_match[1]
+              col[:default] = raw.start_with?('"') ? raw[1..-2] : raw
+            end
+            col[:array] = true if stripped.include?("array: true")
+            tables[current_table][:columns] << col
+
+          # add_column :table, :column, :type
+          elsif (match = stripped.match(/add_column\s+[:"'](\w+)['"']?,\s*[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            table_name, col_name, col_type = match[1], match[2], match[3]
+            if tables[table_name]
+              tables[table_name][:columns].reject! { |c| c[:name] == col_name }
+              col = { name: col_name, type: col_type }
+              col[:null] = false if stripped.include?("null: false")
+              if (def_match = stripped.match(/default:\s*("[^"]*"|\d+(?:\.\d+)?|true|false)/))
+                raw = def_match[1]
+                col[:default] = raw.start_with?('"') ? raw[1..-2] : raw
+              end
+              tables[table_name][:columns] << col
+            end
+
+          # remove_column :table, :column
+          elsif (match = stripped.match(/remove_column\s+[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            table_name, col_name = match[1], match[2]
+            tables[table_name][:columns]&.reject! { |c| c[:name] == col_name } if tables[table_name]
+
+          # rename_column :table, :old, :new
+          elsif (match = stripped.match(/rename_column\s+[:"'](\w+)['"']?,\s*[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            table_name, old_name, new_name = match[1], match[2], match[3]
+            if tables[table_name]
+              col = tables[table_name][:columns].find { |c| c[:name] == old_name }
+              col[:name] = new_name if col
+            end
+
+          # change_column :table, :column, :new_type
+          elsif (match = stripped.match(/change_column\s+[:"'](\w+)['"']?,\s*[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            table_name, col_name, new_type = match[1], match[2], match[3]
+            if tables[table_name]
+              col = tables[table_name][:columns].find { |c| c[:name] == col_name }
+              col[:type] = new_type if col
+            end
+
+          # rename_table :old, :new
+          elsif (match = stripped.match(/rename_table\s+[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            old_name, new_name = match[1], match[2]
+            tables[new_name] = tables.delete(old_name) if tables[old_name]
+
+          # drop_table :name
+          elsif (match = stripped.match(/drop_table\s+[:"'](\w+)/))
+            tables.delete(match[1])
+
+          # add_reference / add_belongs_to :table, :ref
+          elsif (match = stripped.match(/add_(?:reference|belongs_to)\s+[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            table_name, ref_name = match[1], match[2]
+            if tables[table_name]
+              col_name = "#{ref_name}_id"
+              tables[table_name][:columns].reject! { |c| c[:name] == col_name }
+              col = { name: col_name, type: "bigint" }
+              col[:null] = false if stripped.include?("null: false")
+              tables[table_name][:columns] << col
+            end
+
+          # add_index :table, [:cols]
+          elsif (match = stripped.match(/add_index\s+[:"'](\w+)['"']?,\s*\[([^\]]*)\]/))
+            table_name = match[1]
+            cols = match[2].scan(/[:"'](\w+)/).flatten
+            unique = stripped.include?("unique: true")
+            idx_name = stripped.match(/name:\s*[:"']([^"'\s,]+)/)&.send(:[], 1)
+            tables[table_name][:indexes]&.push({ name: idx_name, columns: cols, unique: unique }.compact) if tables[table_name] && cols.any?
+
+          # add_index :table, :single_col
+          elsif (match = stripped.match(/add_index\s+[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            table_name, col_name = match[1], match[2]
+            unique = stripped.include?("unique: true")
+            idx_name = stripped.match(/name:\s*[:"']([^"'\s,]+)/)&.send(:[], 1)
+            tables[table_name][:indexes]&.push({ name: idx_name, columns: [ col_name ], unique: unique }.compact) if tables[table_name]
+
+          # add_foreign_key :from, :to
+          elsif (match = stripped.match(/add_foreign_key\s+[:"'](\w+)['"']?,\s*[:"'](\w+)/))
+            from_table, to_table = match[1], match[2]
+            col_match = stripped.match(/column:\s*[:"'](\w+)/)
+            column = col_match ? col_match[1] : "#{to_table.chomp('s')}_id"
+            if tables[from_table]
+              tables[from_table][:foreign_keys] << { from_table: from_table, to_table: to_table, column: column, primary_key: "id" }
+            end
+
+          # add_timestamps :table
+          elsif (match = stripped.match(/add_timestamps\s+[:"'](\w+)/))
+            table_name = match[1]
+            if tables[table_name]
+              tables[table_name][:columns] << { name: "created_at", type: "datetime", null: false }
+              tables[table_name][:columns] << { name: "updated_at", type: "datetime", null: false }
+            end
+          end
+        end
+      end
+
       def normalize_sql_type(type)
         case type
         when /\Ainteger\z/i, /\Aint\z/i, /\Aint4\z/i then "integer"

data/lib/rails_ai_context/introspectors/view_introspector.rb

@@ -140,7 +140,7 @@ module RailsAiContext
         return {} unless Dir.exist?(views_dir)
 
         counts = Hash.new(0)
-        view_files = Dir.glob(File.join(views_dir, "**/*.{erb,haml,slim}"))
+        view_files = Dir.glob(File.join(views_dir, "**/*.{erb,haml,slim,rb}"))
         view_files.each do |path|
           content = File.read(path) rescue next
           FORM_BUILDER_PATTERNS.each do |name, pattern|
@@ -158,7 +158,7 @@ module RailsAiContext
         return [] unless Dir.exist?(views_dir)
 
         components = Set.new
-        view_files = Dir.glob(File.join(views_dir, "**/*.{erb,haml,slim}"))
+        view_files = Dir.glob(File.join(views_dir, "**/*.{erb,haml,slim,rb}"))
         view_files.each do |path|
           content = File.read(path) rescue next
           # Match render ComponentName.new(...) or render(ComponentName.new(...))

data/lib/rails_ai_context/introspectors/view_template_introspector.rb

@@ -40,11 +40,23 @@ module RailsAiContext
 
           relative = path.sub("#{views_dir}/", "")
           content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
-          templates[relative] = {
-            lines: content.lines.count,
-            partials: extract_partial_refs(content),
-            stimulus: extract_stimulus_refs(content)
-          }
+
+          if phlex_view?(path, content)
+            templates[relative] = {
+              lines: content.lines.count,
+              partials: extract_partial_refs(content),
+              stimulus: extract_stimulus_refs(content),
+              components: extract_phlex_component_renders(content),
+              helpers: extract_phlex_helper_calls(content),
+              phlex: true
+            }
+          else
+            templates[relative] = {
+              lines: content.lines.count,
+              partials: extract_partial_refs(content),
+              stimulus: extract_stimulus_refs(content)
+            }
+          end
         end
         templates
       end
@@ -68,7 +80,7 @@ module RailsAiContext
         max_total = RailsAiContext.configuration.max_view_total_size
         max_single = RailsAiContext.configuration.max_view_file_size
         content = +""
-        Dir.glob(File.join(views_dir, "**", "*.{erb,haml,slim}")).each do |path|
+        Dir.glob(File.join(views_dir, "**", "*.{erb,haml,slim,rb}")).each do |path|
           next if File.directory?(path)
           next if File.size(path) > max_single
           break if content.bytesize >= max_total
@@ -704,6 +716,41 @@ module RailsAiContext
         "Shared partial (#{content.lines.size} lines)"
       end
 
+      # Detect whether a view file is a Phlex view (Ruby DSL, not ERB)
+      def phlex_view?(path, content)
+        return false unless path.end_with?(".rb")
+        # Check for Phlex class patterns: inherits from a View/Base class and defines view_template
+        content.match?(/class\s+\S+\s*<\s*\S+/) && content.match?(/def\s+view_template\b/)
+      end
+
+      # Extract component render calls from Phlex Ruby DSL
+      # Matches: render ComponentName.new(...), render(ComponentName.new(...))
+      # Also matches: render Components::Nested::Name.new(...)
+      def extract_phlex_component_renders(content)
+        components = Set.new
+        content.scan(/render[\s(]+([A-Z]\w+(?:::\w+)*)\.new/).each do |match|
+          components << match[0]
+        end
+        components.to_a.sort
+      end
+
+      # Extract helper method calls from Phlex views
+      # Phlex views use include to pull in helpers, and call them directly
+      PHLEX_HELPER_METHODS = %w[
+        link_to image_tag content_for button_to form_with form_for
+        content_tag tag number_to_currency number_to_human
+        time_ago_in_words distance_of_time_in_words
+        truncate pluralize raw sanitize dom_id
+      ].freeze
+
+      def extract_phlex_helper_calls(content)
+        helpers = []
+        PHLEX_HELPER_METHODS.each do |method|
+          helpers << method if content.match?(/\b#{method}\b/)
+        end
+        helpers
+      end
+
       EXCLUDED_METHODS = %w[
         each map select reject first last size count any? empty? present? blank?
         new build create find where order limit nil? join class html_safe
@@ -750,19 +797,25 @@ module RailsAiContext
         content.scan(/render\s+(?:partial:\s*)?["']([^"']+)["']/).each { |m| refs << m[0] }
         # render @collection
         content.scan(/render\s+@(\w+)/).each { |m| refs << m[0] }
+        # Phlex: render ComponentName.new(...) or render(ComponentName.new(...))
+        content.scan(/render[\s(]+([A-Z]\w+(?:::\w+)*)\.new/).each { |m| refs << m[0] }
         refs.uniq
       end
 
       def extract_stimulus_refs(content)
         refs = []
-        # data-controller="name" or data-controller="name1 name2"
+        # data-controller="name" or data-controller="name1 name2" (ERB/HTML)
         content.scan(/data-controller=["']([^"']+)["']/).each do |m|
           m[0].split.each { |c| refs << c }
         end
-        # data: { controller: "name" }
+        # data: { controller: "name" } (ERB helpers / Phlex hash syntax)
         content.scan(/controller:\s*["']([^"']+)["']/).each do |m|
           m[0].split.each { |c| refs << c }
         end
+        # Phlex keyword: data_controller: "name" (Phlex HTML attributes)
+        content.scan(/data_controller:\s*["']([^"']+)["']/).each do |m|
+          m[0].split.each { |c| refs << c }
+        end
         refs.uniq
       end
     end

data/lib/rails_ai_context/serializers/claude_rules_serializer.rb

@@ -59,6 +59,7 @@ module RailsAiContext
           ""
         ]
 
+        # Compact counts — gems and architecture are already in the root file (CLAUDE.md/AGENTS.md)
         schema = context[:schema]
         if schema.is_a?(Hash) && !schema[:error]
           lines << "- Database: #{schema[:adapter]} — #{schema[:total_tables]} tables"
@@ -70,19 +71,6 @@ module RailsAiContext
         routes = context[:routes]
         lines << "- Routes: #{routes[:total_routes]}" if routes.is_a?(Hash) && !routes[:error]
 
-        gems = context[:gems]
-        if gems.is_a?(Hash) && !gems[:error]
-          notable = gems[:notable_gems] || []
-          notable.group_by { |g| g[:category]&.to_s || "other" }.first(6).each do |cat, gem_list|
-            lines << "- #{cat}: #{gem_list.map { |g| g[:name] }.join(', ')}"
-          end
-        end
-
-        conv = context[:conventions]
-        if conv.is_a?(Hash) && !conv[:error]
-          (conv[:architecture] || []).first(5).each { |p| lines << "- #{p}" }
-        end
-
         lines.concat(full_preset_stack_lines)
 
         # ApplicationController before_actions — apply to all controllers
@@ -114,8 +102,7 @@ module RailsAiContext
         lines = [
           "# Database Tables (#{tables.size})",
           "",
-          "All columns with types are listed below — no need to read db/schema.rb.",
-          "For indexes, foreign keys, or constraints, use `rails_get_schema(table:\"name\")`.",
+          "_Snapshot — may be stale after migrations. Use `rails_get_schema(table:\"name\")` for live data._",
           ""
         ]
 
@@ -195,8 +182,7 @@ module RailsAiContext
         lines = [
           "# ActiveRecord Models (#{models.size})",
           "",
-          "Check this file first for associations, scopes, constants, and validations.",
-          "If you need more detail (callbacks, methods, business logic), use `rails_get_model_details(model:\"Name\")` or Read the file directly.",
+          "_Quick reference — use `rails_get_model_details(model:\"Name\")` for live data with resolved concerns and callbacks._",
           ""
         ]
 
@@ -223,8 +209,13 @@ module RailsAiContext
           scope_names = scopes.map { |s| s.is_a?(Hash) ? s[:name] : s }
           lines << "  scopes: #{scope_names.join(', ')}" if scopes.any?
 
-          # Instance methods — introspector already prioritizes source-defined and filters Devise
-          methods = (data[:instance_methods] || []).reject { |m| m.end_with?("=") }.first(20)
+          # Instance methods — filter Devise/framework internals that add noise
+          devise_noise = %w[after_remembered apply_to_attribute_or_variable clear_reset_password_token
+                            clear_reset_password_token? current_password devise_modules devise_modules?
+                            devise_respond_to_and_will_save_change_to_attribute?]
+          methods = (data[:instance_methods] || [])
+            .reject { |m| m.end_with?("=") || devise_noise.include?(m) }
+            .first(20)
           lines << "  methods: #{methods.join(', ')}" if methods.any?
 
           # Include constants (e.g. STATUSES, MODES) so agents know valid values

data/lib/rails_ai_context/serializers/claude_serializer.rb

@@ -35,10 +35,9 @@ module RailsAiContext
         lines.concat(render_notable_gems)
         lines.concat(render_architecture)
         lines.concat(render_ui_patterns)
-        lines.concat(render_mcp_guide)
-        lines.concat(render_conventions)
         lines.concat(render_commands)
         lines.concat(render_footer)
+        lines.concat(render_mcp_guide_compact)
 
         # Enforce max lines
         max = RailsAiContext.configuration.claude_max_lines
@@ -202,6 +201,10 @@ module RailsAiContext
         render_tools_guide
       end
 
+      def render_mcp_guide_compact
+        render_tools_guide_compact
+      end
+
       def render_conventions
         conv = context[:conventions]
         return [] unless conv.is_a?(Hash) && !conv[:error]
@@ -227,15 +230,43 @@ module RailsAiContext
       end
 
       def render_footer
-        [
-          "## Rules",
-          "- Follow existing patterns and conventions",
-          "- Match existing code style",
-          "- Run tests after changes",
-          "- Do NOT re-read files to verify edits — trust your Edit, validate syntax only",
-          "- Stimulus controllers auto-register — no manual import in controllers/index.js needed",
-          ""
-        ]
+        test_cmd = detect_test_command
+        lines = [ "## Rules" ]
+        lines << "- Run `#{test_cmd}` after changes"
+        lines << "- Do NOT re-read files to verify edits — trust your Edit, validate syntax only"
+
+        # App-specific conventions from introspection
+        conv = context[:conventions]
+        if conv.is_a?(Hash) && !conv[:error]
+          arch = conv[:architecture] || []
+          lines << "- Follow #{arch.join(' + ')} architecture" if arch.any?
+          patterns = conv[:patterns] || []
+          lines << "- Use service objects for business logic" if patterns.include?("service_objects")
+          lines << "- Use form objects for complex forms" if patterns.include?("form_objects")
+          lines << "- Use query objects for complex queries" if patterns.include?("query_objects")
+        end
+
+        # Stimulus auto-register if detected
+        stimulus = context[:stimulus]
+        if stimulus.is_a?(Hash) && !stimulus[:error] && (stimulus[:controllers]&.any? || stimulus[:total_controllers]&.positive?)
+          lines << "- Stimulus controllers auto-register — no manual import in controllers/index.js needed"
+        end
+
+        # Global before_actions — critical for understanding controller flow
+        begin
+          root = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+          app_ctrl_file = File.join(root, "app", "controllers", "application_controller.rb")
+          if File.exist?(app_ctrl_file)
+            source = File.read(app_ctrl_file)
+            before_actions = source.scan(/before_action\s+:([\w!?]+)/).flatten
+            if before_actions.any?
+              lines << "- Global before_actions: #{before_actions.join(', ')}"
+            end
+          end
+        rescue; end
+
+        lines << ""
+        lines
       end
     end
 

data/lib/rails_ai_context/serializers/context_file_serializer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 module RailsAiContext
   module Serializers
     # Orchestrates writing context files to disk in various formats.
@@ -87,7 +89,7 @@ module RailsAiContext
         if File.exist?(filepath) && File.read(filepath) == content
           skipped << filepath
         else
-          File.write(filepath, content)
+          atomic_write(filepath, content)
           written << filepath
         end
       end
@@ -112,15 +114,24 @@ module RailsAiContext
           if new_content == existing
             skipped << filepath
           else
-            File.write(filepath, new_content)
+            atomic_write(filepath, new_content)
             written << filepath
           end
         else
-          File.write(filepath, marked_content)
+          atomic_write(filepath, marked_content)
           written << filepath
         end
       end
 
+      # Write via temp file + rename to avoid partial writes from concurrent processes
+      def atomic_write(filepath, content)
+        dir = File.dirname(filepath)
+        FileUtils.mkdir_p(dir)
+        tmp = File.join(dir, ".#{File.basename(filepath)}.tmp")
+        File.write(tmp, content)
+        File.rename(tmp, filepath)
+      end
+
       def generate_split_rules(formats, output_dir, written, skipped)
         if formats.include?(:claude)
           result = ClaudeRulesSerializer.new(context).call(output_dir)

data/lib/rails_ai_context/serializers/cursor_rules_serializer.rb

@@ -255,7 +255,7 @@ module RailsAiContext
       def render_mcp_tools_rule
         lines = [
           "---",
-          "description: \"Rails tools (25) — MANDATORY, use before reading any reference files\"",
+          "description: \"Rails tools (39) — MANDATORY, use before reading any reference files\"",
           "alwaysApply: true",
           "---",
           ""

data/lib/rails_ai_context/serializers/design_system_helper.rb

@@ -52,7 +52,9 @@ module RailsAiContext
           lines << "## Page Examples — Copy These Patterns"
           lines << ""
 
-          examples.each do |ex|
+          # Cap at 3 examples to avoid bloating context files
+          shown = examples.first(3)
+          shown.each do |ex|
             label = { form_page: "Form Page", list_page: "List/Grid Page", show_page: "Detail Page",
                       dashboard: "Dashboard" }[ex[:type]] || ex[:type].to_s.tr("_", " ").capitalize
             lines << "### #{label} (#{ex[:template]})"
@@ -62,6 +64,11 @@ module RailsAiContext
             lines << "```"
             lines << ""
           end
+
+          if examples.size > 3
+            lines << "_#{examples.size - 3} more examples available via `get_design_system(detail:\"full\")` tool._"
+            lines << ""
+          end
         end
 
         # Responsive patterns

data/lib/rails_ai_context/serializers/opencode_serializer.rb

@@ -35,9 +35,8 @@ module RailsAiContext
         lines.concat(render_notable_gems)
         lines.concat(render_architecture)
         lines.concat(render_ui_patterns)
-        lines.concat(render_mcp_guide)
-        lines.concat(render_conventions)
         lines.concat(render_commands)
+        lines.concat(render_mcp_guide_compact)
         lines.concat(render_footer)
 
         # Enforce max lines
@@ -168,6 +167,10 @@ module RailsAiContext
         render_tools_guide
       end
 
+      def render_mcp_guide_compact
+        render_tools_guide_compact
+      end
+
       def render_conventions
         conv = context[:conventions]
         return [] unless conv.is_a?(Hash) && !conv[:error]