rails_lens 0.2.12 → 0.5.0

data/lib/rails_lens/model_detector.rb

@@ -415,23 +415,69 @@ module RailsLens
       end
 
       def table_exists_with_connection?(model, connection)
-        connection.table_exists?(model.table_name)
+        table_name = model.table_name
+
+        # Handle schema-qualified table names for PostgreSQL (e.g., 'audit.audit_logs')
+        if connection.adapter_name == 'PostgreSQL' && table_name.include?('.')
+          with_schema_in_search_path(connection, table_name) do |unqualified_name|
+            connection.table_exists?(unqualified_name) || connection.views.include?(unqualified_name)
+          end
+        else
+          # Check both tables and views
+          return true if connection.table_exists?(table_name)
+          return true if connection.views.include?(table_name)
+
+          # Fallback for SQLite: direct sqlite_master query for views
+          if connection.adapter_name.downcase.include?('sqlite')
+            check_sqlite_view(connection, table_name)
+          else
+            false
+          end
+        end
       rescue StandardError
         false
       end
 
       def columns_empty_with_connection?(model, connection)
-        connection.columns(model.table_name).empty?
+        table_name = model.table_name
+
+        if connection.adapter_name == 'PostgreSQL' && table_name.include?('.')
+          with_schema_in_search_path(connection, table_name) do |unqualified_name|
+            connection.columns(unqualified_name).empty?
+          end
+        else
+          connection.columns(table_name).empty?
+        end
       rescue StandardError
         true
       end
 
       def get_column_count_with_connection(model, connection)
-        connection.columns(model.table_name).size
+        table_name = model.table_name
+
+        if connection.adapter_name == 'PostgreSQL' && table_name.include?('.')
+          with_schema_in_search_path(connection, table_name) do |unqualified_name|
+            connection.columns(unqualified_name).size
+          end
+        else
+          connection.columns(table_name).size
+        end
       rescue StandardError
         0
       end
 
+      # Helper to execute block with schema in PostgreSQL search_path
+      def with_schema_in_search_path(connection, qualified_table_name)
+        schema_name, unqualified_name = qualified_table_name.split('.', 2)
+        original_search_path = connection.schema_search_path
+        begin
+          connection.schema_search_path = "#{schema_name}, #{original_search_path}"
+          yield unqualified_name
+        ensure
+          connection.schema_search_path = original_search_path
+        end
+      end
+
       def has_sti_column?(model)
         return false unless model.table_exists?
 

data/lib/rails_lens/model_source.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Base class for model sources
+  # Model sources provide pluggable discovery of different model types
+  # (e.g., ActiveRecord, ActiveCypher, etc.)
+  #
+  # Gems can register their own model source by defining:
+  #   GemName::RailsLensModelSource < RailsLens::ModelSource
+  #
+  # Example:
+  #   module MyOrm
+  #     class ModelSource < ::RailsLens::ModelSource
+  #       def self.models(options = {})
+  #         # Return array of model classes
+  #       end
+  #
+  #       def self.file_patterns
+  #         ['app/my_models/**/*.rb']
+  #       end
+  #
+  #       def self.annotate_model(model, options = {})
+  #         # Return { status: :annotated/:skipped/:failed, model: name, ... }
+  #       end
+  #
+  #       def self.remove_annotation(model)
+  #         # Return { status: :removed/:skipped, model: name, ... }
+  #       end
+  #     end
+  #
+  #     RailsLensModelSource = ModelSource
+  #   end
+  #
+  class ModelSource
+    class << self
+      # Return array of model classes to annotate
+      # @param options [Hash] Options passed from CLI
+      # @return [Array<Class>] Array of model classes
+      def models(_options = {})
+        raise NotImplementedError, "#{name} must implement .models"
+      end
+
+      # Return file patterns for annotation removal
+      # Used when removing annotations by filesystem scan
+      # @return [Array<String>] Glob patterns relative to Rails.root
+      def file_patterns
+        raise NotImplementedError, "#{name} must implement .file_patterns"
+      end
+
+      # Annotate a single model
+      # @param model [Class] The model class to annotate
+      # @param options [Hash] Options passed from CLI
+      # @return [Hash] Result with :status (:annotated, :skipped, :failed), :model, :file, :message
+      def annotate_model(_model, _options = {})
+        raise NotImplementedError, "#{name} must implement .annotate_model"
+      end
+
+      # Remove annotation from a single model
+      # @param model [Class] The model class
+      # @return [Hash] Result with :status (:removed, :skipped), :model, :file
+      def remove_annotation(_model)
+        raise NotImplementedError, "#{name} must implement .remove_annotation"
+      end
+
+      # Human-readable name for this source (used in logging)
+      # @return [String]
+      def source_name
+        name.demodulize.sub(/Source$/, '').underscore.humanize
+      end
+    end
+  end
+end

data/lib/rails_lens/model_source_loader.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Discovers and loads model sources from gems
+  # Gems can register sources in two ways:
+  # 1. Define GemName::RailsLensModelSource (auto-discovery)
+  # 2. Call RailsLens::ModelSourceLoader.register(SourceClass) explicitly
+  class ModelSourceLoader
+    @registered_sources = []
+
+    class << self
+      # Register a model source explicitly
+      # Use this when gem naming doesn't follow conventions
+      # @param source [Class] Model source class
+      def register(source)
+        return unless valid_source?(source)
+
+        @registered_sources ||= []
+        @registered_sources << source unless @registered_sources.include?(source)
+      end
+
+      # Load all available model sources
+      # @return [Array<Class>] Array of model source classes
+      def load_sources
+        sources = []
+
+        # Always include ActiveRecord source first
+        sources << ModelSources::ActiveRecordSource
+
+        # Include explicitly registered sources
+        @registered_sources ||= []
+        sources.concat(@registered_sources)
+
+        # Load gem-provided sources via auto-discovery if enabled
+        sources.concat(load_gem_sources) if config_enabled?
+
+        # Deduplicate in case a source was both registered and auto-discovered
+        sources.uniq
+      end
+
+      # List all loaded sources (for debugging/info)
+      # @return [Array<Hash>] Source info with name and class
+      def list_sources
+        load_sources.map do |source|
+          {
+            name: source.source_name,
+            class: source.name,
+            patterns: source.file_patterns
+          }
+        end
+      end
+
+      private
+
+      def config_enabled?
+        config = RailsLens.config.model_sources
+        config && config[:enabled]
+      end
+
+      def load_gem_sources
+        sources = []
+
+        Gem.loaded_specs.each_key do |gem_name|
+          source = find_source_for_gem(gem_name)
+          sources << source if source && valid_source?(source)
+        end
+
+        sources
+      end
+
+      def find_source_for_gem(gem_name)
+        # Skip gems that might cause autoload issues
+        return nil if %w[digest openssl uri net json].include?(gem_name)
+
+        # Convert gem name to constant (e.g., 'activecypher' -> 'ActiveCypher')
+        # Use ActiveSupport's camelize for proper Rails-style conversion
+        gem_constant_name = gem_name.gsub('-', '_').camelize
+
+        # Check if gem constant exists without triggering autoload
+        return nil unless Object.const_defined?(gem_constant_name, false)
+
+        gem_constant = Object.const_get(gem_constant_name)
+        return nil unless gem_constant.is_a?(Module)
+
+        # Check if it has a RailsLensModelSource
+        return nil unless gem_constant.const_defined?('RailsLensModelSource', false)
+
+        gem_constant.const_get('RailsLensModelSource')
+      rescue NameError
+        nil
+      rescue StandardError => e
+        log_error("Error loading model source from #{gem_name}: #{e.message}")
+        nil
+      end
+
+      def valid_source?(klass)
+        return false unless klass.is_a?(Class)
+
+        required_methods = %i[models file_patterns annotate_model remove_annotation]
+        required_methods.all? { |m| klass.respond_to?(m) }
+      end
+
+      def log_error(message)
+        error_reporting = RailsLens.config.model_sources[:error_reporting] || :warn
+
+        case error_reporting
+        when :silent
+          # Do nothing
+        when :warn
+          RailsLens.logger.warn "[RailsLens ModelSources] #{message}"
+        when :verbose
+          RailsLens.logger.error "[RailsLens ModelSources] #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/model_sources/active_record_source.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ModelSources
+    # Built-in model source for ActiveRecord models
+    class ActiveRecordSource < ModelSource
+      class << self
+        def models(options = {})
+          # Convert models option to include option for ModelDetector
+          opts = options.dup
+          opts[:include] = opts.delete(:models) if opts[:models]
+
+          models = ModelDetector.detect_models(opts)
+
+          # Filter abstract classes based on options
+          if opts[:include_abstract]
+            # Include all models
+          elsif opts[:abstract_only]
+            models = models.select(&:abstract_class?)
+          else
+            # Default: exclude abstract classes
+            models = models.reject(&:abstract_class?)
+          end
+
+          models
+        end
+
+        def file_patterns
+          ['app/models/**/*.rb']
+        end
+
+        def annotate_model(model, options = {})
+          # Use the optimized connection-pooled annotation
+          results = { annotated: [], skipped: [], failed: [] }
+
+          # Group this single model by connection pool for consistency
+          begin
+            pool = model.connection_pool
+            pool.with_connection do |connection|
+              Schema::AnnotationManager.process_model_with_connection(model, connection, results, options)
+            end
+          rescue StandardError
+            # Fallback without connection management
+            Schema::AnnotationManager.process_model_with_connection(model, nil, results, options)
+          end
+
+          if results[:annotated].include?(model.name)
+            { status: :annotated, model: model.name, file: model_file_path(model) }
+          elsif results[:failed].any? { |f| f[:model] == model.name }
+            failure = results[:failed].find { |f| f[:model] == model.name }
+            { status: :failed, model: model.name, message: failure[:error] }
+          else
+            { status: :skipped, model: model.name }
+          end
+        end
+
+        def remove_annotation(model)
+          manager = Schema::AnnotationManager.new(model)
+          if manager.remove_annotations
+            { status: :removed, model: model.name, file: model_file_path(model) }
+          else
+            { status: :skipped, model: model.name }
+          end
+        rescue StandardError => e
+          { status: :failed, model: model.name, message: e.message }
+        end
+
+        def source_name
+          'ActiveRecord'
+        end
+
+        private
+
+        def model_file_path(model)
+          return nil unless model.name
+
+          const_source_location = Object.const_source_location(model.name)
+          return const_source_location.first if const_source_location
+
+          if defined?(Rails.root)
+            Rails.root.join('app', 'models', "#{model.name.underscore}.rb").to_s
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/note_codes.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Compact note codes for LLM-readable annotations
+  # Format: "column_name:CODE" or "association:CODE"
+  module NoteCodes
+    # Column constraint codes
+    NOT_NULL = 'NOT_NULL'
+    DEFAULT = 'DEFAULT'
+    LIMIT = 'LIMIT'
+
+    # Index codes
+    INDEX = 'INDEX'
+    POLY_INDEX = 'POLY_INDEX'
+    COMP_INDEX = 'COMP_INDEX'
+    REDUND_IDX = 'REDUND_IDX'
+
+    # Type codes
+    USE_DECIMAL = 'USE_DECIMAL'
+    USE_INTEGER = 'USE_INTEGER'
+
+    # Association codes
+    INVERSE_OF = 'INVERSE_OF'
+    N_PLUS_ONE = 'N_PLUS_ONE'
+    COUNTER_CACHE = 'COUNTER_CACHE'
+    FK_CONSTRAINT = 'FK_CONSTRAINT'
+
+    # Best practices codes
+    NO_TIMESTAMPS = 'NO_TIMESTAMPS'
+    PARTIAL_TS = 'PARTIAL_TS'
+    STORAGE = 'STORAGE'
+
+    # STI codes
+    STI_INDEX = 'STI_INDEX'
+    STI_NOT_NULL = 'STI_NOT_NULL'
+
+    # View codes
+    VIEW_READONLY = 'VIEW_READONLY'
+    ADD_READONLY = 'ADD_READONLY'
+    MATVIEW_STALE = 'MATVIEW_STALE'
+    ADD_REFRESH = 'ADD_REFRESH'
+    NESTED_VIEW = 'NESTED_VIEW'
+    VIEW_PROTECT = 'VIEW_PROTECT'
+
+    # Structure codes
+    MISSING = 'MISSING'
+    DEPTH_CACHE = 'DEPTH_CACHE'
+
+    class << self
+      # Build a compact note string
+      # @param subject [String, nil] column/association name (nil for model-level)
+      # @param code [String] note code constant
+      # @return [String] formatted note
+      def note(subject, code)
+        subject ? "#{subject}:#{code}" : code
+      end
+    end
+  end
+end

data/lib/rails_lens/providers/callbacks_provider.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Providers
+    class CallbacksProvider < SectionProviderBase
+      def analyzer_class
+        Analyzers::Callbacks
+      end
+
+      def applicable?(model_class)
+        # Only applicable to non-abstract models with callbacks
+        return false if model_class.abstract_class?
+
+        # Check if model has any callbacks defined (Rails 8+ uses unified chains)
+        RailsLens::Analyzers::Callbacks::CALLBACK_CHAINS.any? do |chain_name|
+          chain_method = "_#{chain_name}_callbacks"
+          model_class.respond_to?(chain_method) && model_class.public_send(chain_method).present?
+        end
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/rails_lens/providers/extensions_provider.rb

@@ -13,7 +13,7 @@ module RailsLens
         return nil if results[:annotations].empty?
 
         {
-          title: '== Extensions',
+          title: '[extensions]',
           content: results[:annotations].join("\n")
         }
       end

data/lib/rails_lens/providers/view_provider.rb

@@ -14,7 +14,7 @@ module RailsLens
         return nil unless view_metadata.view_exists?
 
         {
-          title: '== View Information',
+          title: '[view]',
           content: generate_view_content(view_metadata)
         }
       end
@@ -25,39 +25,25 @@ module RailsLens
         lines = []
 
         # View type (regular or materialized)
-        if view_metadata.view_type
-          lines << "View Type: #{view_metadata.view_type}"
-        end
+        lines << "type = \"#{view_metadata.view_type}\"" if view_metadata.view_type
 
         # Updatable status
-        lines << "Updatable: #{view_metadata.updatable? ? 'Yes' : 'No'}"
+        lines << "updatable = #{view_metadata.updatable?}"
 
         # Dependencies
         dependencies = view_metadata.dependencies
         if dependencies.any?
-          lines << "Dependencies: #{dependencies.join(', ')}"
+          lines << "dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
         end
 
         # Refresh strategy for materialized views
         if view_metadata.materialized_view? && view_metadata.refresh_strategy
-          lines << "Refresh Strategy: #{view_metadata.refresh_strategy}"
+          lines << "refresh_strategy = \"#{view_metadata.refresh_strategy}\""
         end
 
         # Last refreshed timestamp for materialized views
         if view_metadata.materialized_view? && view_metadata.last_refreshed
-          lines << "Last Refreshed: #{view_metadata.last_refreshed}"
-        end
-
-        # View definition (truncated for readability)
-        if view_metadata.view_definition
-          definition = view_metadata.view_definition
-          # Truncate long definitions
-          if definition.length > 200
-            definition = "#{definition[0..200]}..."
-          end
-          # Remove extra whitespace and newlines
-          definition = definition.gsub(/\s+/, ' ').strip
-          lines << "Definition: #{definition}"
+          lines << "last_refreshed = \"#{view_metadata.last_refreshed}\""
         end
 
         lines.join("\n")

data/lib/rails_lens/schema/adapters/base.rb

@@ -175,6 +175,42 @@ module RailsLens
             connection.supports_comments?
         end
 
+        def show_triggers?
+          RailsLens.config.schema[:format_options][:show_triggers]
+        end
+
+        def fetch_triggers
+          # Override in database-specific adapters
+          []
+        end
+
+        def add_triggers_toml(lines)
+          triggers = fetch_triggers
+          return if triggers.empty?
+
+          lines << ''
+          lines << 'triggers = ['
+          triggers.each_with_index do |trigger, i|
+            line = '  { '
+            attrs = []
+            attrs << "name = \"#{trigger[:name]}\""
+            attrs << "event = \"#{trigger[:event]}\""
+            attrs << "timing = \"#{trigger[:timing]}\""
+            attrs << "function = \"#{trigger[:function]}\""
+            attrs << "for_each = \"#{trigger[:for_each]}\"" if trigger[:for_each]
+            attrs << "condition = \"#{escape_toml_string(trigger[:condition])}\"" if trigger[:condition]
+            line += attrs.join(', ')
+            line += ' }'
+            line += ',' if i < triggers.length - 1
+            lines << line
+          end
+          lines << ']'
+        end
+
+        def escape_toml_string(str)
+          str.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+        end
+
         # Structured formatting methods
         def add_columns_structured(lines)
           lines << 'COLUMNS:'
@@ -252,8 +288,9 @@ module RailsLens
             attrs = []
             attrs << "name = \"#{column.name}\""
             attrs << "type = \"#{column.type}\""
-            attrs << 'primary_key = true' if primary_key?(column)
-            attrs << "nullable = #{column.null}"
+            attrs << 'pk = true' if primary_key?(column)
+            # Only add null = false when NOT nullable (omit when nullable for brevity)
+            attrs << 'null = false' unless column.null
             attrs << "default = #{format_toml_value(column.default)}" if column.default && show_defaults?
             line += attrs.join(', ')
             line += ' }'

data/lib/rails_lens/schema/adapters/database_info.rb

@@ -13,30 +13,24 @@ module RailsLens
 
         def generate_annotation
           lines = []
-          lines << '== Database Information'
-          lines << "Adapter: #{adapter_name}"
-          lines << "Database: #{database_name}"
-          lines << "Version: #{database_version}"
-          lines << "Encoding: #{database_encoding}" if respond_to?(:database_encoding)
-          lines << "Collation: #{database_collation}" if respond_to?(:database_collation)
-          lines << ''
+          lines << '[database_info]'
+          lines << "adapter = \"#{adapter_name}\""
+          lines << "database = \"#{database_name}\""
+          lines << "version = \"#{database_version}\""
+          enc = database_encoding
+          lines << "encoding = \"#{enc}\"" if enc
+          coll = database_collation
+          lines << "collation = \"#{coll}\"" if coll
 
           # Add extensions for PostgreSQL
           if adapter_name == 'PostgreSQL' && extensions.any?
-            lines << 'Enabled Extensions:'
-            extensions.each do |ext|
-              lines << "  - #{ext['name']} (#{ext['version']})"
-            end
-            lines << ''
+            ext_list = extensions.map { |e| "{ name = \"#{e['name']}\", version = \"#{e['version']}\" }" }
+            lines << "extensions = [#{ext_list.join(', ')}]"
           end
 
           # Add schemas for PostgreSQL
           if adapter_name == 'PostgreSQL' && schemas.any?
-            lines << 'Database Schemas:'
-            schemas.each do |schema|
-              lines << "  - #{schema}"
-            end
-            lines << ''
+            lines << "schemas = [#{schemas.map { |s| "\"#{s}\"" }.join(', ')}]"
           end
 
           lines.join("\n")

data/lib/rails_lens/schema/adapters/mysql.rb

@@ -40,6 +40,7 @@ module RailsLens
           add_columns_toml(lines)
           add_indexes_toml(lines) if show_indexes?
           add_foreign_keys_toml(lines) if show_foreign_keys?
+          add_triggers_toml(lines) if show_triggers?
           add_partitions_toml(lines) if has_partitions?
 
           lines.join("\n")
@@ -385,6 +386,80 @@ module RailsLens
         def view_last_refreshed
           nil # MySQL doesn't have materialized views
         end
+
+        # Fetch triggers for the table
+        def fetch_triggers
+          quoted_table = connection.quote(unqualified_table_name)
+          result = connection.exec_query(<<~SQL.squish, 'MySQL Table Triggers')
+            SELECT
+              TRIGGER_NAME AS name,
+              ACTION_TIMING AS timing,
+              EVENT_MANIPULATION AS event,
+              'ROW' AS for_each,
+              ACTION_STATEMENT AS action_statement
+            FROM information_schema.TRIGGERS
+            WHERE TRIGGER_SCHEMA = DATABASE()
+              AND EVENT_OBJECT_TABLE = #{quoted_table}
+            ORDER BY TRIGGER_NAME
+          SQL
+
+          result.rows.map do |row|
+            {
+              name: row[0],
+              timing: row[1],
+              event: row[2],
+              for_each: row[3],
+              function: extract_function_call(row[4]),
+              definition: row[4]
+            }
+          end
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
+          RailsLens.logger.debug { "Failed to fetch triggers for #{table_name}: #{e.message}" }
+          []
+        end
+
+        # Extract function/procedure call from trigger action statement
+        def extract_function_call(action_statement)
+          return nil unless action_statement
+
+          # Match CALL with optional schema prefix and backticks: CALL `schema`.`proc` or CALL schema.proc or CALL proc
+          match = action_statement.match(/CALL\s+(?:`?(\w+)`?\.)?`?(\w+)`?/i)
+          if match
+            schema_part = match[1]
+            proc_name = match[2]
+            schema_part ? "#{schema_part}.#{proc_name}" : proc_name
+          else
+            'inline'
+          end
+        end
+
+        # Fetch all user-defined functions
+        def self.fetch_functions(connection)
+          result = connection.exec_query(<<~SQL.squish, 'MySQL Functions')
+            SELECT
+              ROUTINE_NAME AS name,
+              ROUTINE_SCHEMA AS `schema`,
+              DATA_TYPE AS return_type,
+              ROUTINE_COMMENT AS description
+            FROM information_schema.ROUTINES
+            WHERE ROUTINE_SCHEMA = DATABASE()
+              AND ROUTINE_TYPE = 'FUNCTION'
+            ORDER BY ROUTINE_NAME
+          SQL
+
+          result.rows.map do |row|
+            {
+              name: row[0],
+              schema: row[1],
+              language: 'SQL',
+              return_type: row[2],
+              description: row[3]
+            }
+          end
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
+          RailsLens.logger.debug { "Failed to fetch functions: #{e.message}" }
+          []
+        end
       end
     end
   end