type-guessr 0.0.2 → 0.0.4

data/lib/ruby_lsp/type_guessr/dsl/ar_type_mapper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../../../type_guessr/core/types"
+
+module RubyLsp
+  module TypeGuessr
+    module Dsl
+      # Maps ActiveRecord column type strings to TypeGuessr Types.
+      # Pure mapping with no external dependencies.
+      # AR-specific: Mongoid provides Ruby types directly in field declarations.
+      module ArTypeMapper
+        def self.map(ar_type, nullable: true)
+          base = case ar_type.to_s
+                 when "string", "text"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("String")
+                 when "integer", "bigint"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("Integer")
+                 when "boolean"
+                   ::TypeGuessr::Core::Types::Union.new([
+                                                          ::TypeGuessr::Core::Types::ClassInstance.for("TrueClass"),
+                                                          ::TypeGuessr::Core::Types::ClassInstance.for("FalseClass"),
+                                                        ])
+                 when "float"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("Float")
+                 when "decimal"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("BigDecimal")
+                 when "date"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("Date")
+                 when "datetime", "timestamp"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("ActiveSupport::TimeWithZone")
+                 when "json", "jsonb"
+                   ::TypeGuessr::Core::Types::ClassInstance.for("Hash")
+                 else
+                   ::TypeGuessr::Core::Types::Unknown.instance
+                 end
+
+          if nullable && !base.is_a?(::TypeGuessr::Core::Types::Unknown)
+            nil_type = ::TypeGuessr::Core::Types::ClassInstance.for("NilClass")
+            if base.is_a?(::TypeGuessr::Core::Types::Union)
+              ::TypeGuessr::Core::Types::Union.new(base.types + [nil_type])
+            else
+              ::TypeGuessr::Core::Types::Union.new([base, nil_type])
+            end
+          else
+            base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/type_guessr/dsl.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "dsl/activerecord_adapter"

data/lib/ruby_lsp/type_guessr/dsl_type_registrar.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "dsl"
+
+module RubyLsp
+  module TypeGuessr
+    # Pure orchestrator for DSL type registration.
+    # No framework logic, no cache logic — delegates everything to Adapters.
+    class DslTypeRegistrar
+      def initialize(signature_registry:, code_index:, project_root:, adapters: nil)
+        @signature_registry = signature_registry
+        @code_index = code_index
+        @project_root = project_root
+        @adapters = adapters || default_adapters
+        @base_registered = false
+        @log_callback = nil
+      end
+
+      def on_log(&block)
+        @log_callback = block
+        active_adapters.each { |a| a.on_log(&block) }
+      end
+
+      def register_all(runner_client: nil)
+        unless @base_registered
+          active_adapters.each { |a| a.register_base_methods(signature_registry: @signature_registry) }
+          @base_registered = true
+        end
+
+        active_adapters.each do |adapter|
+          adapter.register_models(
+            runner_client: runner_client,
+            signature_registry: @signature_registry,
+            code_index: @code_index
+          )
+        end
+      end
+
+      def check_and_refresh(runner_client: nil)
+        active_adapters.each do |adapter|
+          next unless adapter.changed?
+
+          adapter.refresh(
+            runner_client: runner_client,
+            signature_registry: @signature_registry,
+            code_index: @code_index
+          )
+        end
+      end
+
+      private def active_adapters
+        @adapters.select(&:applicable?)
+      end
+
+      private def default_adapters
+        [Dsl::ActiveRecordAdapter.new(project_root: @project_root)]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/type_guessr/hover.rb

@@ -121,49 +121,55 @@ module RubyLsp
           class_name = extract_class_name(receiver_type)
 
           if class_name
-            # Try to find DefNode first (for project methods)
-            # Use the same inference logic as DefNode hover
-            unless receiver_type.is_a?(Types::SingletonType)
-              def_node = @runtime_adapter.lookup_method(class_name, call_node.method.to_s)
-              if def_node
-                add_def_node_hover(def_node)
-                return
+            method_name_str = call_node.method.to_s
+            skip_stdlib_rbs = if receiver_type.is_a?(Types::SingletonType)
+                                @runtime_adapter.skip_stdlib_rbs_class_method?(class_name, method_name_str)
+                              else
+                                @runtime_adapter.skip_stdlib_rbs_method?(class_name, method_name_str)
+                              end
+
+            # Methods marked skip_stdlib_rbs skip DefNode + RBS → go straight to fallback (resolver)
+            unless skip_stdlib_rbs
+              # Try to find DefNode first (for project methods)
+              unless receiver_type.is_a?(Types::SingletonType)
+                def_node = @runtime_adapter.lookup_method(class_name, method_name_str)
+                if def_node
+                  add_def_node_hover(def_node)
+                  return
+                end
               end
-            end
 
-            # Fall back to RBS signature lookup (for stdlib/gems)
-            # Use class method lookup for SingletonType (e.g., RBS::Environment.from_loader)
-            # RuntimeAdapter resolves the actual method owner (e.g., Object for #tap)
-            rbs_result = if receiver_type.is_a?(Types::SingletonType)
-                           @runtime_adapter.get_rbs_class_method_signatures(
-                             class_name, call_node.method.to_s
-                           )
-                         else
-                           @runtime_adapter.get_rbs_method_signatures(
-                             class_name, call_node.method.to_s
-                           )
-                         end
-
-            signatures = rbs_result[:signatures]
-            owner = rbs_result[:owner]
-
-            if signatures.any?
-              # Format the signature(s)
-              sig_strs = signatures.map { |sig| sig.method_type.to_s }
-              content = "**Guessed Signature:** `#{sig_strs.first}`"
-
-              if debug_enabled?
-                content += "\n\n**[TypeGuessr Debug]**"
-                content += "\n\n**Receiver:** `#{receiver_type}`"
-                content += "\n\n**Defined in:** `#{owner}`" if owner != class_name
-                if sig_strs.size > 1
-                  content += "\n\n**Overloads:**\n"
-                  sig_strs.each { |s| content += "- `#{s}`\n" }
+              # Fall back to RBS signature lookup (for stdlib/gems)
+              rbs_result = if receiver_type.is_a?(Types::SingletonType)
+                             @runtime_adapter.get_rbs_class_method_signatures(
+                               class_name, method_name_str
+                             )
+                           else
+                             @runtime_adapter.get_rbs_method_signatures(
+                               class_name, method_name_str
+                             )
+                           end
+
+              signatures = rbs_result[:signatures]
+              owner = rbs_result[:owner]
+
+              if signatures.any?
+                sig_strs = signatures.map { |sig| sig.method_type.to_s }
+                content = "**Guessed Signature:** `#{sig_strs.first}`"
+
+                if debug_enabled?
+                  content += "\n\n**[TypeGuessr Debug]**"
+                  content += "\n\n**Receiver:** `#{receiver_type}`"
+                  content += "\n\n**Defined in:** `#{owner}`" if owner != class_name
+                  if sig_strs.size > 1
+                    content += "\n\n**Overloads:**\n"
+                    sig_strs.each { |s| content += "- `#{s}`\n" }
+                  end
                 end
-              end
 
-              @response_builder.push(content, category: :documentation)
-              return
+                @response_builder.push(content, category: :documentation)
+                return
+              end
             end
           end
         end
@@ -354,7 +360,7 @@ module RubyLsp
       end
 
       private def debug_enabled?
-        Config.debug?
+        ::TypeGuessr::Core::Config.debug?
       end
 
       private def build_debug_info(result, ir_node = nil)

data/lib/ruby_lsp/type_guessr/rails_server_addon.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# This file is loaded in the Rails runner process (not the LSP server)
+# via RunnerClient.register_server_addon.
+# RubyLsp::Rails::ServerAddon is already defined when this file is required.
+
+module RubyLsp
+  module TypeGuessr
+    # ServerAddon that runs inside the Rails runner process.
+    # Queries ActiveRecord runtime for model metadata (columns, enums, associations, scopes).
+    class RailsServerAddon < ::RubyLsp::Rails::ServerAddon
+      def name
+        "TypeGuessr"
+      end
+
+      def execute(request, params)
+        case request
+        when "model_metadata"
+          handle_model_metadata(params)
+        end
+      end
+
+      private def handle_model_metadata(params)
+        class_name = params[:name]
+        klass = class_name.constantize
+
+        return send_error_response("#{class_name} is not an ActiveRecord model") unless active_record_model?(klass)
+
+        send_result({
+                      columns: extract_columns(klass),
+                      enums: extract_enums(klass),
+                      associations: extract_associations(klass),
+                      scopes: extract_scopes(klass)
+                    })
+      rescue NameError
+        send_error_response("#{class_name} is not a valid class")
+      rescue StandardError => e
+        send_error_response("#{e.class}: #{e.message}")
+      end
+
+      private def active_record_model?(klass)
+        klass < ::ActiveRecord::Base
+      rescue StandardError
+        false
+      end
+
+      private def extract_columns(klass)
+        klass.columns.map do |col|
+          [col.name, col.type.to_s, col.null]
+        end
+      end
+
+      private def extract_enums(klass)
+        return {} unless klass.respond_to?(:defined_enums)
+
+        klass.defined_enums
+      end
+
+      private def extract_associations(klass)
+        klass.reflect_on_all_associations.map do |assoc|
+          {
+            name: assoc.name.to_s,
+            macro: assoc.macro.to_s,
+            class_name: assoc.class_name
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      private def extract_scopes(klass)
+        enum_values = klass.respond_to?(:defined_enums) ? klass.defined_enums.values.flat_map(&:keys) : []
+        exclude = Set.new(enum_values + enum_values.map { |v| "not_#{v}" })
+
+        klass.singleton_methods(false)
+             .map(&:to_s)
+             .reject { |m| exclude.include?(m) || m.start_with?("find_by_", "create_", "build_") }
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/ruby_lsp/type_guessr/runtime_adapter.rb

@@ -1,19 +1,8 @@
 # frozen_string_literal: true
 
 require "prism"
-require_relative "../../type_guessr/core/converter/prism_converter"
-require_relative "../../type_guessr/core/index/location_index"
-require_relative "../../type_guessr/core/registry/method_registry"
-require_relative "../../type_guessr/core/registry/instance_variable_registry"
-require_relative "../../type_guessr/core/registry/class_variable_registry"
-require_relative "../../type_guessr/core/registry/signature_registry"
-require_relative "../../type_guessr/core/inference/resolver"
-require_relative "../../type_guessr/core/signature_builder"
-require_relative "../../type_guessr/core/type_simplifier"
-require_relative "../../type_guessr/core/node_context_helper"
-require_relative "../../type_guessr/core/cache/gem_signature_cache"
-require_relative "../../type_guessr/core/cache/gem_dependency_resolver"
-require_relative "../../type_guessr/core/cache/gem_signature_extractor"
+require_relative "../../type_guessr/core"
+require_relative "dsl_type_registrar"
 require_relative "code_index_adapter"
 require_relative "type_inferrer"
 
@@ -29,7 +18,6 @@ module RubyLsp
         @message_queue = message_queue
         @converter = ::TypeGuessr::Core::Converter::PrismConverter.new
         @location_index = ::TypeGuessr::Core::Index::LocationIndex.new
-        @signature_registry = ::TypeGuessr::Core::Registry::SignatureRegistry.instance
         @indexing_completed = false
         @mutex = Mutex.new
         @original_type_inferrer = nil
@@ -37,6 +25,10 @@ module RubyLsp
         # Create CodeIndexAdapter wrapping RubyIndexer
         @code_index = CodeIndexAdapter.new(global_state&.index)
 
+        # Create SignatureRegistry with code_index for ancestor chain traversal
+        @signature_registry = ::TypeGuessr::Core::Registry::SignatureRegistry.new(code_index: @code_index)
+        ::TypeGuessr::Core::Registry::SignatureRegistry.instance = @signature_registry
+
         # Create method registry with code_index for inheritance lookup
         @method_registry = ::TypeGuessr::Core::Registry::MethodRegistry.new(
           code_index: @code_index
@@ -211,6 +203,19 @@ module RubyLsp
         end
       end
 
+      # Check if a method should skip stdlib/gem RBS lookup in hover.
+      # Returns true for entries registered by DSL adapters (e.g., AR column accessor)
+      # so that hover goes directly to the resolver fallback instead of showing RBS signatures.
+      def skip_stdlib_rbs_method?(class_name, method_name)
+        entry = @signature_registry.lookup(class_name, method_name)
+        entry.is_a?(::TypeGuessr::Core::Registry::SignatureRegistry::GemMethodEntry) && entry.skip_stdlib_rbs?
+      end
+
+      def skip_stdlib_rbs_class_method?(class_name, method_name)
+        entry = @signature_registry.lookup_class_method(class_name, method_name)
+        entry.is_a?(::TypeGuessr::Core::Registry::SignatureRegistry::GemMethodEntry) && entry.skip_stdlib_rbs?
+      end
+
       # Start background indexing of all project files
       def start_indexing
         Thread.new do
@@ -248,10 +253,19 @@ module RubyLsp
           # Connect on-demand inference callback for Unguessed gem methods
           @signature_registry.on_demand_inferrer = method(:infer_gem_file_on_demand)
 
+          # Register DSL types (AR column accessors, enums, associations, scopes)
+          register_dsl_types
+
           @indexing_completed = true
 
+          # Start schema watch loop for auto-refresh
+          start_schema_watch_loop
+
           # Background inference: fully infer gems that have Unguessed entries (opt-in)
-          background_infer_gems(result[:unguessed_gems], result[:cache]) if Config.background_gem_indexing? && result && result[:unguessed_gems].any?
+          if ::TypeGuessr::Core::Config.background_gem_indexing? && result && result[:unguessed_gems].any?
+            background_infer_gems(result[:unguessed_gems],
+                                  result[:cache])
+          end
         rescue StandardError => e
           log_message("Error during file indexing: #{e.message}\n#{e.backtrace.first(10).join("\n")}")
           @indexing_completed = true
@@ -444,7 +458,7 @@ module RubyLsp
           method_registry: temp_method_registry,
           location_index: temp_location_index
         )
-        timeout = Config.gem_inference_timeout
+        timeout = ::TypeGuessr::Core::Config.gem_inference_timeout
         signatures = extractor.extract(files, timeout: timeout)
 
         t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -754,6 +768,66 @@ module RubyLsp
         log_message("Index stabilized at #{previous_count} entries.")
       end
 
+      private def discover_runner_client
+        rails_addon = ::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.4.0", "< 0.5.0")
+        rails_addon.rails_runner_client
+      rescue ::RubyLsp::Addon::AddonNotFoundError, ::RubyLsp::Addon::IncompatibleApiError
+        nil
+      rescue StandardError => e
+        log_message("Failed to discover RunnerClient: #{e.message}")
+        nil
+      end
+
+      private def register_dsl_types
+        workspace_path = @global_state.workspace_path
+        return unless workspace_path
+
+        @dsl_registrar = DslTypeRegistrar.new(
+          signature_registry: @signature_registry,
+          code_index: @code_index,
+          project_root: workspace_path
+        )
+        @dsl_registrar.on_log { |msg| log_message("[DSL] #{msg}") }
+
+        runner_client = wait_for_runner_client
+        @dsl_registrar.register_all(runner_client: runner_client)
+      rescue StandardError => e
+        log_message("DSL type registration failed: #{e.message}\n#{e.backtrace.first(3).join("\n")}")
+      end
+
+      # Wait for ruby-lsp-rails RunnerClient to transition from NullClient.
+      # 3s interval × max 10 attempts = max 30s.
+      private def wait_for_runner_client
+        log_message("[DSL] Waiting for RunnerClient...")
+        max_attempts = 10
+
+        max_attempts.times do |_i|
+          client = discover_runner_client
+          if client.respond_to?(:connected?) && client.connected?
+            log_message("[DSL] RunnerClient ready (#{client.class})")
+            return client
+          end
+
+          sleep(3)
+        end
+
+        log_message("[DSL] RunnerClient timeout after #{max_attempts} attempts")
+        nil
+      end
+
+      private def start_schema_watch_loop
+        return unless @dsl_registrar
+
+        Thread.new do
+          loop do
+            sleep(45)
+            @dsl_registrar.check_and_refresh(runner_client: discover_runner_client)
+          rescue StandardError => e
+            log_message("Schema watch error: #{e.message}")
+          end
+        end
+      end
+
       private def log_message(message)
         return unless @message_queue
         return if @message_queue.closed?

data/lib/type-guessr.rb

@@ -8,23 +8,12 @@ end
 # Load version
 require_relative "type_guessr/version"
 
-# Load core components (IR-based architecture)
-require_relative "type_guessr/core/types"
-require_relative "type_guessr/core/node_key_generator"
-require_relative "type_guessr/core/node_context_helper"
-require_relative "type_guessr/core/ir/nodes"
-require_relative "type_guessr/core/index/location_index"
-require_relative "type_guessr/core/converter/prism_converter"
-require_relative "type_guessr/core/converter/rbs_converter"
-require_relative "type_guessr/core/inference/result"
-require_relative "type_guessr/core/inference/resolver"
-require_relative "type_guessr/core/registry/signature_registry"
-require_relative "type_guessr/core/logger"
+# Load core components
+require_relative "type_guessr/core"
 
 # Load Ruby LSP integration
 # NOTE: addon.rb is NOT required here - it's auto-discovered by Ruby LSP
 # Requiring it here would cause double activation
-require_relative "ruby_lsp/type_guessr/config"
 require_relative "ruby_lsp/type_guessr/constants"
 require_relative "ruby_lsp/type_guessr/runtime_adapter"
 require_relative "ruby_lsp/type_guessr/hover"

data/lib/type_guessr/core/cache/gem_signature_cache.rb

@@ -3,6 +3,7 @@
 require "json"
 require "digest/sha2"
 require "fileutils"
+require_relative "../../version"
 
 module TypeGuessr
   module Core
@@ -11,7 +12,7 @@ module TypeGuessr
       # Cache key = gem name + version + hash of transitive dependencies.
       # Files stored at: ~/.cache/type-guessr/gem-signatures/{name}-{version}-{dep_hash}.json
       class GemSignatureCache
-        CACHE_FORMAT_VERSION = 1
+        CACHE_FORMAT_VERSION = 2
 
         # @param cache_dir [String, nil] Override cache directory (for testing)
         def initialize(cache_dir: nil)
@@ -79,7 +80,7 @@ module TypeGuessr
 
         private def default_cache_dir
           xdg_cache = ENV.fetch("XDG_CACHE_HOME", File.join(Dir.home, ".cache"))
-          File.join(xdg_cache, "type-guessr", "gem-signatures")
+          File.join(xdg_cache, "type-guessr", "gem-signatures", TypeGuessr::VERSION)
         end
 
         private def cache_path(gem_name, gem_version, transitive_deps)

data/lib/type_guessr/core/cache.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "cache/gem_signature_cache"
+require_relative "cache/gem_dependency_resolver"
+require_relative "cache/gem_signature_extractor"

data/lib/{ruby_lsp/type_guessr → type_guessr/core}/config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module RubyLsp
-  module TypeGuessr
+module TypeGuessr
+  module Core
     # Loads TypeGuessr settings from .type-guessr.yml in the current working directory.
     #
     # Defaults: