type-guessr 0.0.1 → 0.0.3

data/lib/ruby_lsp/type_guessr/type_inferrer.rb

@@ -10,7 +10,8 @@ module RubyLsp
       # Core layer shortcuts
       Types = ::TypeGuessr::Core::Types
       IR = ::TypeGuessr::Core::IR
-      private_constant :Types, :IR
+      NodeContextHelper = ::TypeGuessr::Core::NodeContextHelper
+      private_constant :Types, :IR, :NodeContextHelper
 
       def initialize(index, runtime_adapter)
         super(index)
@@ -26,14 +27,7 @@ module RubyLsp
         guess_type_from_ir(node_context)
       end
 
-      private
-
-      # Attempt to guess type using IR-based inference
-      # Returns GuessedType only when type can be resolved
-      #
-      # @param node_context [RubyLsp::NodeContext] The context of the node
-      # @return [GuessedType, nil] The guessed type or nil if unknown
-      def guess_type_from_ir(node_context)
+      private def guess_type_from_ir(node_context)
         node = node_context.node
 
         # For CallNode, we need to infer the receiver's type
@@ -64,9 +58,9 @@ module RubyLsp
       # @param node [Prism::Node] The Prism node
       # @param node_context [RubyLsp::NodeContext] The context of the node
       # @return [TypeGuessr::Core::IR::Node, nil] The IR node or nil
-      def find_ir_node(node, node_context)
-        scope_id = generate_scope_id(node_context)
-        node_hash = generate_node_hash(node, node_context)
+      private def find_ir_node(node, node_context)
+        scope_id = NodeContextHelper.generate_scope_id(node_context)
+        node_hash = NodeContextHelper.generate_node_hash(node, node_context)
         return nil unless node_hash
 
         node_key = "#{scope_id}:#{node_hash}"
@@ -76,7 +70,7 @@ module RubyLsp
       # Extract the variable node from a CallNode's receiver
       # @param call_node [Prism::CallNode] The call node
       # @return [Prism::Node, nil] The receiver variable node or nil
-      def extract_receiver_variable(call_node)
+      private def extract_receiver_variable(call_node)
         receiver = call_node.receiver
         return nil unless receiver
 
@@ -92,7 +86,7 @@ module RubyLsp
       # Check if the node is a variable node that we can analyze
       # @param node [Prism::Node] The node to check
       # @return [Boolean] true if the node is a variable node
-      def variable_node?(node)
+      private def variable_node?(node)
         case node
         when Prism::LocalVariableReadNode, Prism::LocalVariableWriteNode, Prism::LocalVariableTargetNode,
              Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode, Prism::InstanceVariableTargetNode,
@@ -104,97 +98,6 @@ module RubyLsp
           false
         end
       end
-
-      # Generate scope_id from node_context
-      # Format: "ClassName#method_name" or "ClassName" or "#method_name" or ""
-      # @param node_context [RubyLsp::NodeContext] The context of the node
-      # @return [String] The scope identifier
-      def generate_scope_id(node_context)
-        class_path = node_context.nesting.map do |n|
-          n.is_a?(String) ? n : n.name.to_s
-        end.join("::")
-
-        method_name = node_context.surrounding_method
-
-        if method_name
-          "#{class_path}##{method_name}"
-        else
-          class_path
-        end
-      end
-
-      # Generate node_hash from Prism node to match IR node_hash format
-      # @param node [Prism::Node] The Prism node
-      # @param node_context [RubyLsp::NodeContext] The context (for block param detection)
-      # @return [String, nil] The node hash or nil
-      def generate_node_hash(node, node_context)
-        line = node.location.start_line
-        case node
-        when Prism::LocalVariableWriteNode, Prism::LocalVariableTargetNode
-          "local_write:#{node.name}:#{line}"
-        when Prism::LocalVariableReadNode
-          "local_read:#{node.name}:#{line}"
-        when Prism::InstanceVariableWriteNode, Prism::InstanceVariableTargetNode
-          "ivar_write:#{node.name}:#{line}"
-        when Prism::InstanceVariableReadNode
-          "ivar_read:#{node.name}:#{line}"
-        when Prism::RequiredParameterNode, Prism::OptionalParameterNode, Prism::RestParameterNode,
-             Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
-             Prism::KeywordRestParameterNode, Prism::BlockParameterNode
-          # Check if this is a block parameter
-          if block_parameter?(node, node_context)
-            index = block_parameter_index(node, node_context)
-            "bparam:#{index}:#{line}"
-          else
-            "param:#{node.name}:#{line}"
-          end
-        end
-      end
-
-      # Check if a parameter node is inside a block (not a method definition)
-      # @param node [Prism::Node] The parameter node
-      # @param node_context [RubyLsp::NodeContext] The context
-      # @return [Boolean] true if inside a block
-      def block_parameter?(node, node_context)
-        call_node = node_context.call_node
-        return false unless call_node&.block
-
-        block_params = call_node.block.parameters&.parameters
-        return false unless block_params
-
-        all_params = collect_block_params(block_params)
-        all_params.include?(node)
-      end
-
-      # Get the index of a block parameter
-      # @param node [Prism::Node] The parameter node
-      # @param node_context [RubyLsp::NodeContext] The context
-      # @return [Integer] The parameter index
-      def block_parameter_index(node, node_context)
-        call_node = node_context.call_node
-        return 0 unless call_node&.block
-
-        block_params = call_node.block.parameters&.parameters
-        return 0 unless block_params
-
-        all_params = collect_block_params(block_params)
-        all_params.index(node) || 0
-      end
-
-      # Collect all parameters from block parameters node
-      # @param block_params [Prism::ParametersNode] The block parameters
-      # @return [Array<Prism::Node>] All parameter nodes
-      def collect_block_params(block_params)
-        params = []
-        params.concat(block_params.requireds) if block_params.respond_to?(:requireds)
-        params.concat(block_params.optionals) if block_params.respond_to?(:optionals)
-        params << block_params.rest if block_params.respond_to?(:rest) && block_params.rest
-        params.concat(block_params.posts) if block_params.respond_to?(:posts)
-        params.concat(block_params.keywords) if block_params.respond_to?(:keywords)
-        params << block_params.keyword_rest if block_params.respond_to?(:keyword_rest) && block_params.keyword_rest
-        params << block_params.block if block_params.respond_to?(:block) && block_params.block
-        params.compact
-      end
     end
   end
 end

data/lib/type-guessr.rb

@@ -8,21 +8,13 @@ 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/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/rbs_provider"
-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"
 require_relative "ruby_lsp/type_guessr/debug_server"

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+module TypeGuessr
+  module Core
+    module Cache
+      # Resolves gem dependencies from Gemfile.lock and partitions files by gem.
+      # Provides topological ordering for dependency-aware cache building.
+      class GemDependencyResolver
+        GEM_PATH_PATTERN = %r{/gems/([^/]+)-(\d[^/]*)/}
+
+        # @param lockfile_path [String] Path to Gemfile.lock
+        def initialize(lockfile_path)
+          @lockfile_path = lockfile_path
+          @lockfile = parse_lockfile
+        end
+
+        # Partition file paths into gem files and project files
+        # @param file_paths [Array<String>] All indexable file paths
+        # @return [Hash] { gems: { name => { version:, files:, transitive_deps: {} } }, project_files: [] }
+        def partition(file_paths)
+          gems = {}
+          project_files = []
+
+          file_paths.each do |path|
+            match = path.match(GEM_PATH_PATTERN)
+            if match
+              gem_name = match[1]
+              gem_version = match[2]
+
+              # Only include gems from the lockfile
+              if @lockfile.key?(gem_name)
+                gems[gem_name] ||= {
+                  version: gem_version,
+                  files: [],
+                  transitive_deps: resolve_transitive_deps(gem_name)
+                }
+                gems[gem_name][:files] << path
+              else
+                project_files << path
+              end
+            else
+              project_files << path
+            end
+          end
+
+          { gems: gems, project_files: project_files }
+        end
+
+        # Return gem names in topological order (leaves first, roots last)
+        # @param gem_names [Array<String>] Gem names to sort
+        # @return [Array<String>] Sorted gem names
+        def topological_order(gem_names)
+          visited = {}
+          order = []
+
+          gem_names.each do |name|
+            visit(name, gem_names, visited, order)
+          end
+
+          order
+        end
+
+        private def parse_lockfile
+          return {} unless File.exist?(@lockfile_path)
+
+          content = File.read(@lockfile_path)
+          parser = Bundler::LockfileParser.new(content)
+
+          parser.specs.to_h do |spec|
+            deps = spec.dependencies.map(&:name)
+            [spec.name, { version: spec.version.to_s, deps: deps }]
+          end
+        end
+
+        private def resolve_transitive_deps(gem_name)
+          result = {}
+          queue = (@lockfile.dig(gem_name, :deps) || []).dup
+          visited = Set.new
+
+          while (dep_name = queue.shift)
+            next if visited.include?(dep_name)
+
+            visited << dep_name
+
+            dep_info = @lockfile[dep_name]
+            next unless dep_info
+
+            result[dep_name] = dep_info[:version]
+            queue.concat(dep_info[:deps] || [])
+          end
+
+          result
+        end
+
+        private def visit(name, valid_names, visited, order)
+          return if visited[name]
+
+          visited[name] = true
+
+          # Visit dependencies first
+          deps = @lockfile.dig(name, :deps) || []
+          deps.each do |dep|
+            visit(dep, valid_names, visited, order) if valid_names.include?(dep)
+          end
+
+          order << name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest/sha2"
+require "fileutils"
+require_relative "../../version"
+
+module TypeGuessr
+  module Core
+    module Cache
+      # Manages disk-based cache of gem method signatures.
+      # 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 = 2
+
+        # @param cache_dir [String, nil] Override cache directory (for testing)
+        def initialize(cache_dir: nil)
+          @cache_dir = cache_dir || default_cache_dir
+        end
+
+        # Check if a cached file exists for the given gem
+        # @param gem_name [String]
+        # @param gem_version [String]
+        # @param transitive_deps [Hash{String => String}] { dep_name => dep_version }
+        # @return [Boolean]
+        def cached?(gem_name, gem_version, transitive_deps)
+          File.exist?(cache_path(gem_name, gem_version, transitive_deps))
+        end
+
+        # Load cached signatures
+        # @param gem_name [String]
+        # @param gem_version [String]
+        # @param transitive_deps [Hash{String => String}]
+        # @return [Hash, nil] { "instance_methods" => {...}, "class_methods" => {...} } or nil on failure
+        def load(gem_name, gem_version, transitive_deps)
+          path = cache_path(gem_name, gem_version, transitive_deps)
+          return nil unless File.exist?(path)
+
+          data = JSON.parse(File.read(path))
+          return nil unless data["version"] == CACHE_FORMAT_VERSION
+
+          {
+            "instance_methods" => data["instance_methods"] || {},
+            "class_methods" => data["class_methods"] || {},
+            "fully_inferred" => data.fetch("fully_inferred", true),
+            "inference_timeout" => data.fetch("inference_timeout", false)
+          }
+        rescue JSON::ParserError, Errno::ENOENT
+          nil
+        end
+
+        # Save signatures to cache
+        # @param gem_name [String]
+        # @param gem_version [String]
+        # @param transitive_deps [Hash{String => String}]
+        # @param instance_methods [Hash] { class_name => { method_name => serialized_entry } }
+        # @param class_methods [Hash] { class_name => { method_name => serialized_entry } }
+        # @param fully_inferred [Boolean] Whether types are fully inferred (false = Unguessed placeholders)
+        def save(gem_name, gem_version, transitive_deps,
+                 instance_methods:, class_methods:, fully_inferred: true, inference_timeout: false)
+          path = cache_path(gem_name, gem_version, transitive_deps)
+          FileUtils.mkdir_p(File.dirname(path))
+
+          data = {
+            "version" => CACHE_FORMAT_VERSION,
+            "fully_inferred" => fully_inferred,
+            "inference_timeout" => inference_timeout,
+            "instance_methods" => instance_methods,
+            "class_methods" => class_methods
+          }
+
+          File.write(path, JSON.generate(data))
+        end
+
+        # Delete all cached files
+        def clear!
+          FileUtils.rm_rf(@cache_dir)
+        end
+
+        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", TypeGuessr::VERSION)
+        end
+
+        private def cache_path(gem_name, gem_version, transitive_deps)
+          dep_hash = compute_dep_hash(transitive_deps)
+          File.join(@cache_dir, "#{gem_name}-#{gem_version}-#{dep_hash}.json")
+        end
+
+        private def compute_dep_hash(transitive_deps)
+          sorted_pairs = transitive_deps.sort.map { |name, version| "#{name}:#{version}" }.join(",")
+          Digest::SHA256.hexdigest("v1:#{sorted_pairs}")[0..5]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../type_serializer"
+
+module TypeGuessr
+  module Core
+    module Cache
+      # Extracts method signatures from indexed gem files.
+      # Iterates DefNodes in the method registry and builds serialized signatures.
+      class GemSignatureExtractor
+        # @param signature_builder [SignatureBuilder]
+        # @param method_registry [Registry::MethodRegistry]
+        # @param location_index [Index::LocationIndex]
+        def initialize(signature_builder:, method_registry:, location_index:)
+          @signature_builder = signature_builder
+          @method_registry = method_registry
+          @location_index = location_index
+        end
+
+        # Extract all method signatures from indexed gem files
+        # @param gem_files [Array<String>] File paths belonging to this gem
+        # @param timeout [Float, nil] Max seconds for inference. Returns nil on timeout.
+        # @return [Hash, nil] { instance_methods:, class_methods: } or nil on timeout
+        def extract(gem_files, timeout: nil)
+          gem_def_nodes = collect_def_nodes(gem_files)
+          instance_methods = {}
+          class_methods = {}
+          deadline = timeout ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout : nil
+          check_counter = 0
+
+          @method_registry.each_entry do |class_name, method_name, def_node|
+            next unless gem_def_nodes.include?(def_node)
+
+            if deadline
+              check_counter += 1
+              return nil if (check_counter % 100).zero? && Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+            end
+
+            sig = @signature_builder.build_from_def_node(def_node)
+            serialized = serialize_signature(sig)
+
+            if def_node.singleton
+              class_methods[class_name] ||= {}
+              class_methods[class_name][method_name] = serialized
+            else
+              instance_methods[class_name] ||= {}
+              instance_methods[class_name][method_name] = serialized
+            end
+
+            # module_function: also register as class method
+            if def_node.module_function
+              class_methods[class_name] ||= {}
+              class_methods[class_name][method_name] = serialized
+            end
+          rescue StandardError
+            # Skip methods that fail to infer (circular deps, etc.)
+            next
+          end
+
+          { instance_methods: instance_methods, class_methods: class_methods }
+        end
+
+        # Collect all DefNodes from gem files using the location index
+        # @param gem_files [Array<String>] File paths belonging to this gem
+        # @return [Set<IR::DefNode>] Set of DefNodes for O(1) membership check
+        private def collect_def_nodes(gem_files)
+          result = Set.new
+          gem_files.each do |file_path|
+            @location_index.nodes_for_file(file_path).each do |node|
+              result << node if node.is_a?(IR::DefNode)
+            end
+          end
+          result
+        end
+
+        private def serialize_signature(method_signature)
+          {
+            "return_type" => TypeSerializer.serialize(method_signature.return_type),
+            "params" => method_signature.params.map do |p|
+              { "name" => p.name.to_s, "kind" => p.kind.to_s, "type" => TypeSerializer.serialize(p.type) }
+            end
+          }
+        end
+      end
+    end
+  end
+end

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,68 +1,55 @@
 # 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:
     # - enabled: true
     # - debug: false
-    # - union_cutoff: 10
-    # - hash_shape_max_fields: 15
-    # - max_chain_depth: 5
     module Config
       CONFIG_FILENAME = ".type-guessr.yml"
 
-      # Default values for type inference limits
-      DEFAULT_UNION_CUTOFF = 10
-      DEFAULT_HASH_SHAPE_MAX_FIELDS = 15
-      DEFAULT_MAX_CHAIN_DEPTH = 5
-
-      module_function
-
-      def reset!
+      module_function def reset!
         @cached_config = nil
-        @cached_mtime = nil
       end
 
-      def enabled?
+      module_function def enabled?
         value = load_config.fetch("enabled", true)
         value != false
       end
 
-      def debug?
+      module_function def debug?
         load_config["debug"] == true
       end
 
-      def debug_server_enabled?
+      module_function def debug_server_enabled?
         config = load_config
         return config["debug_server"] if config.key?("debug_server")
 
         debug?
       end
 
-      def debug_server_port
-        load_config.fetch("debug_server_port", 7010)
+      module_function def background_gem_indexing?
+        load_config.fetch("background_gem_indexing", false) == true
       end
 
-      def union_cutoff
-        load_config.fetch("union_cutoff", DEFAULT_UNION_CUTOFF)
+      module_function def debug_server_port
+        load_config.fetch("debug_server_port", 7010)
       end
 
-      def hash_shape_max_fields
-        load_config.fetch("hash_shape_max_fields", DEFAULT_HASH_SHAPE_MAX_FIELDS)
+      module_function def gem_inference_timeout
+        load_config.fetch("gem_inference_timeout", 1.0)
       end
 
-      def max_chain_depth
-        load_config.fetch("max_chain_depth", DEFAULT_MAX_CHAIN_DEPTH)
-      end
+      module_function def load_config
+        return @cached_config if @cached_config
 
-      def load_config
         path = File.join(Dir.pwd, CONFIG_FILENAME)
-        return default_config if !File.exist?(path)
-
-        mtime = File.mtime(path)
-        return @cached_config if @cached_config && @cached_mtime == mtime
+        if !File.exist?(path)
+          @cached_config = default_config
+          return @cached_config
+        end
 
         require "yaml"
 
@@ -71,14 +58,12 @@ module RubyLsp
         data = {} unless data.is_a?(Hash)
 
         @cached_config = default_config.merge(data)
-        @cached_mtime = mtime
-        @cached_config
       rescue StandardError => e
         warn("[TypeGuessr] Error loading config file: #{e.message}")
         default_config
       end
 
-      def default_config
+      module_function def default_config
         {
           "enabled" => true,
           "debug" => false