type-guessr 0.0.1 → 0.0.3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: type-guessr
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - riseshia
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
   requirement: !ruby/object:Gem::Requirement
@@ -26,33 +40,68 @@ dependencies:
 description: TypeGuessr provides heuristic type inference
 email:
 - ''
-executables: []
+executables:
+- type-guessr
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- exe/type-guessr
 - lib/ruby_lsp/type_guessr/addon.rb
-- lib/ruby_lsp/type_guessr/config.rb
+- lib/ruby_lsp/type_guessr/code_index_adapter.rb
+- lib/ruby_lsp/type_guessr/constants.rb
+- lib/ruby_lsp/type_guessr/debug_graph_builder.rb
 - lib/ruby_lsp/type_guessr/debug_server.rb
-- lib/ruby_lsp/type_guessr/graph_builder.rb
+- lib/ruby_lsp/type_guessr/dsl.rb
+- lib/ruby_lsp/type_guessr/dsl/activerecord_adapter.rb
+- lib/ruby_lsp/type_guessr/dsl/ar_schema_watcher.rb
+- lib/ruby_lsp/type_guessr/dsl/ar_type_mapper.rb
+- lib/ruby_lsp/type_guessr/dsl_type_registrar.rb
 - lib/ruby_lsp/type_guessr/hover.rb
+- lib/ruby_lsp/type_guessr/rails_server_addon.rb
 - lib/ruby_lsp/type_guessr/runtime_adapter.rb
 - lib/ruby_lsp/type_guessr/type_inferrer.rb
 - lib/type-guessr.rb
+- lib/type_guessr/core.rb
+- lib/type_guessr/core/cache.rb
+- lib/type_guessr/core/cache/gem_dependency_resolver.rb
+- lib/type_guessr/core/cache/gem_signature_cache.rb
+- lib/type_guessr/core/cache/gem_signature_extractor.rb
+- lib/type_guessr/core/config.rb
+- lib/type_guessr/core/converter.rb
+- lib/type_guessr/core/converter/call_converter.rb
+- lib/type_guessr/core/converter/container_mutation_converter.rb
+- lib/type_guessr/core/converter/context.rb
+- lib/type_guessr/core/converter/control_flow_converter.rb
+- lib/type_guessr/core/converter/definition_converter.rb
+- lib/type_guessr/core/converter/literal_converter.rb
 - lib/type_guessr/core/converter/prism_converter.rb
 - lib/type_guessr/core/converter/rbs_converter.rb
+- lib/type_guessr/core/converter/registration.rb
+- lib/type_guessr/core/converter/variable_converter.rb
+- lib/type_guessr/core/index.rb
 - lib/type_guessr/core/index/location_index.rb
+- lib/type_guessr/core/inference.rb
 - lib/type_guessr/core/inference/resolver.rb
 - lib/type_guessr/core/inference/result.rb
+- lib/type_guessr/core/ir.rb
 - lib/type_guessr/core/ir/nodes.rb
 - lib/type_guessr/core/logger.rb
-- lib/type_guessr/core/rbs_provider.rb
+- lib/type_guessr/core/node_context_helper.rb
+- lib/type_guessr/core/node_key_generator.rb
+- lib/type_guessr/core/registry.rb
+- lib/type_guessr/core/registry/class_variable_registry.rb
+- lib/type_guessr/core/registry/instance_variable_registry.rb
 - lib/type_guessr/core/registry/method_registry.rb
-- lib/type_guessr/core/registry/variable_registry.rb
-- lib/type_guessr/core/signature_provider.rb
+- lib/type_guessr/core/registry/signature_registry.rb
+- lib/type_guessr/core/signature_builder.rb
+- lib/type_guessr/core/type_serializer.rb
 - lib/type_guessr/core/type_simplifier.rb
 - lib/type_guessr/core/types.rb
+- lib/type_guessr/mcp/file_watcher.rb
+- lib/type_guessr/mcp/server.rb
+- lib/type_guessr/mcp/standalone_runtime.rb
 - lib/type_guessr/version.rb
 homepage: https://github.com/riseshia/type-guessr
 licenses: []
@@ -75,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A heuristic type inference tool for Ruby
 test_files: []

data/lib/type_guessr/core/rbs_provider.rb

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-require "rbs"
-require_relative "types"
-require_relative "logger"
-require_relative "converter/rbs_converter"
-
-module TypeGuessr
-  module Core
-    # RBSProvider loads and queries RBS signature information
-    # Provides lazy loading of RBS environment for method signatures
-    # Uses RBSConverter to convert RBS types to internal type system
-    class RBSProvider
-      include Singleton
-
-      # Represents a method signature from RBS
-      class Signature
-        attr_reader :method_type
-
-        def initialize(method_type)
-          @method_type = method_type
-        end
-      end
-
-      def initialize
-        @env = nil
-        @loader = nil
-        @converter = Converter::RBSConverter.new
-      end
-
-      # Preload RBS environment (for eager loading during addon activation)
-      # @return [self]
-      def preload
-        ensure_environment_loaded
-        self
-      end
-
-      # Get method signatures for a class and method name
-      # @param class_name [String] the class name
-      # @param method_name [String] the method name
-      # @return [Array<Signature>] array of method signatures
-      def get_method_signatures(class_name, method_name)
-        ensure_environment_loaded
-
-        # Build the type name
-        type_name = build_type_name(class_name)
-
-        # Check if class exists in RBS before building (avoids RuntimeError for project classes)
-        return [] unless @env.class_decl?(type_name)
-
-        # Use RBS::DefinitionBuilder to get method definitions
-        builder = RBS::DefinitionBuilder.new(env: @env)
-        definition = builder.build_instance(type_name)
-
-        # Get the method definition
-        method_def = definition.methods[method_name.to_sym]
-        return [] unless method_def
-
-        # Return all method types (overloads)
-        method_def.method_types.map { |mt| Signature.new(mt) }
-      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => _e
-        # Class not found in RBS
-        []
-      rescue StandardError => e
-        # If anything goes wrong, return empty array
-        Logger.error("RBSProvider error", e)
-        []
-      end
-
-      # Get the return type of a method call with overload resolution
-      # @param class_name [String] the receiver class name
-      # @param method_name [String] the method name
-      # @param arg_types [Array<Types::Type>] argument types for overload matching
-      # @return [Types::Type] the return type (Unknown if not found)
-      def get_method_return_type(class_name, method_name, arg_types = [])
-        signatures = get_method_signatures(class_name, method_name)
-        return Types::Unknown.instance if signatures.empty?
-
-        # Find best matching overload based on argument types
-        best_match = find_best_overload(signatures, arg_types)
-        return_type = best_match.method_type.type.return_type
-
-        @converter.convert(return_type)
-      end
-
-      # Get block parameter types for a method
-      # @param class_name [String] the receiver class name
-      # @param method_name [String] the method name
-      # @return [Array<Types::Type>] array of block parameter types (empty if no block)
-      def get_block_param_types(class_name, method_name)
-        block_sig = find_block_signature(class_name, method_name)
-        return [] unless block_sig
-
-        extract_block_param_types(block_sig)
-      end
-
-      # Get class method signatures (singleton methods like File.read, Array.new)
-      # @param class_name [String] the class name
-      # @param method_name [String] the method name
-      # @return [Array<Signature>] array of method signatures
-      def get_class_method_signatures(class_name, method_name)
-        ensure_environment_loaded
-
-        # Build the type name
-        type_name = build_type_name(class_name)
-
-        # Check if class exists in RBS before building (avoids RuntimeError for project classes)
-        return [] unless @env.class_decl?(type_name)
-
-        # Use RBS::DefinitionBuilder to get singleton method definitions
-        builder = RBS::DefinitionBuilder.new(env: @env)
-        definition = builder.build_singleton(type_name)
-
-        # Get the method definition
-        method_def = definition.methods[method_name.to_sym]
-        return [] unless method_def
-
-        # Return all method types (overloads)
-        method_def.method_types.map { |mt| Signature.new(mt) }
-      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => _e
-        # Class not found in RBS
-        []
-      rescue StandardError => e
-        # If anything goes wrong, return empty array
-        Logger.error("RBSProvider class method error", e)
-        []
-      end
-
-      # Get the return type of a class method call
-      # @param class_name [String] the class name
-      # @param method_name [String] the method name
-      # @param arg_types [Array<Types::Type>] the argument types
-      # @return [Types::Type] the return type (Unknown if not found)
-      def get_class_method_return_type(class_name, method_name, arg_types = [])
-        signatures = get_class_method_signatures(class_name, method_name)
-        return Types::Unknown.instance if signatures.empty?
-
-        # Find best matching overload based on argument types
-        best_match = find_best_overload(signatures, arg_types)
-        return_type = best_match.method_type.type.return_type
-
-        @converter.convert(return_type)
-      end
-
-      private
-
-      # Find a method signature that has a block
-      # @param class_name [String] the receiver class name
-      # @param method_name [String] the method name
-      # @return [RBS::MethodType, nil] the method type with block, or nil
-      def find_block_signature(class_name, method_name)
-        signatures = get_method_signatures(class_name, method_name)
-        return nil if signatures.empty?
-
-        # Find the signature with a block
-        sig_with_block = signatures.find { |s| s.method_type.block }
-        sig_with_block&.method_type
-      end
-
-      # Extract block parameter types from a method type
-      # @param method_type [RBS::MethodType] the method type
-      # @param substitutions [Hash{Symbol => Types::Type}] type variable substitutions (e.g., { Elem: Integer })
-      # @return [Array<Types::Type>] array of parameter types
-      def extract_block_param_types(method_type, substitutions: {})
-        return [] unless method_type.block
-
-        block_func = method_type.block.type
-        block_func.required_positionals.flat_map do |param|
-          # Handle Tuple types (e.g., [K, V] in Hash#each) by flattening
-          raw_types = if param.type.is_a?(RBS::Types::Tuple)
-                        param.type.types.map { |t| @converter.convert(t) }
-                      else
-                        [@converter.convert(param.type)]
-                      end
-          # Apply substitutions after conversion
-          raw_types.map { |t| t.substitute(substitutions) }
-        end
-      end
-
-      def ensure_environment_loaded
-        return if @env
-
-        @loader = RBS::EnvironmentLoader.new
-
-        # Add optional library paths if they exist
-        # loader.add(path: Pathname("sig")) if Dir.exist?("sig")
-
-        # Load environment (this automatically loads core/stdlib)
-        @env = RBS::Environment.from_loader(@loader).resolve_type_names
-      rescue StandardError => e
-        Logger.error("Failed to load RBS environment", e)
-        # Fallback to empty environment
-        @env = RBS::Environment.new
-      end
-
-      def build_type_name(class_name)
-        # Parse class name to handle namespaced classes like "Foo::Bar"
-        parts = class_name.split("::")
-        namespace_parts = parts[0...-1]
-        name = parts.last
-
-        namespace = if namespace_parts.empty?
-                      RBS::Namespace.root
-                    else
-                      RBS::Namespace.parse(namespace_parts.join("::"))
-                    end
-
-        RBS::TypeName.new(name: name.to_sym, namespace: namespace)
-      end
-
-      # Find the best matching overload for given argument types
-      # @param signatures [Array<Signature>] available overloads
-      # @param arg_types [Array<Types::Type>] argument types
-      # @return [Signature] best matching signature (first if no match)
-      def find_best_overload(signatures, arg_types)
-        return signatures.first if arg_types.empty?
-
-        # Score each overload
-        scored = signatures.map do |sig|
-          score = calculate_overload_score(sig.method_type, arg_types)
-          [sig, score]
-        end
-
-        # Return best scoring overload, or first if all scores are 0
-        best = scored.max_by { |_sig, score| score }
-        best[1].positive? ? best[0] : signatures.first
-      end
-
-      # Calculate match score for an overload
-      # @param method_type [RBS::MethodType] the method type
-      # @param arg_types [Array<Types::Type>] argument types
-      # @return [Integer] score (higher = better match)
-      def calculate_overload_score(method_type, arg_types)
-        func = method_type.type
-        required = func.required_positionals
-        optional = func.optional_positionals
-        rest = func.rest_positionals
-
-        # Check argument count
-        min_args = required.size
-        max_args = rest ? Float::INFINITY : required.size + optional.size
-        return 0 unless arg_types.size.between?(min_args, max_args)
-
-        # Score each argument match
-        score = 0
-        arg_types.each_with_index do |arg_type, i|
-          param = if i < required.size
-                    required[i]
-                  elsif i < required.size + optional.size
-                    optional[i - required.size]
-                  else
-                    rest
-                  end
-
-          break unless param
-
-          score += type_match_score(arg_type, param.type)
-        end
-
-        score
-      end
-
-      # Calculate match score between our type and RBS parameter type
-      # @param our_type [Types::Type] our type representation
-      # @param rbs_type [RBS::Types::t] RBS type
-      # @return [Integer] score (0 = no match, 1 = weak match, 2 = exact match)
-      def type_match_score(our_type, rbs_type)
-        case rbs_type
-        when RBS::Types::ClassInstance
-          # Exact class match
-          class_name = rbs_type.name.to_s.delete_prefix("::")
-          return 2 if types_match_class?(our_type, class_name)
-
-          0
-        when RBS::Types::Union
-          # Check if our type matches any member
-          max_score = rbs_type.types.map { |t| type_match_score(our_type, t) }.max || 0
-          max_score.positive? ? 1 : 0
-        else
-          # Unknown RBS type - give weak match to avoid penalizing
-          1
-        end
-      end
-
-      # Check if our type matches a class name
-      # @param our_type [Types::Type] our type
-      # @param class_name [String] class name to match
-      # @return [Boolean] true if types match
-      def types_match_class?(our_type, class_name)
-        case our_type
-        when Types::ClassInstance
-          our_type.name == class_name
-        when Types::ArrayType
-          class_name == "Array"
-        when Types::HashShape
-          class_name == "Hash"
-        else
-          false
-        end
-      end
-    end
-  end
-end

data/lib/type_guessr/core/registry/variable_registry.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module TypeGuessr
-  module Core
-    module Registry
-      # Stores and retrieves instance/class variable write nodes
-      # Supports inheritance chain traversal for instance variables when ancestry_provider is set
-      class VariableRegistry
-        # Callback for getting class ancestors
-        # @return [Proc, nil] A proc that takes class_name and returns array of ancestor names
-        attr_accessor :ancestry_provider
-
-        # @param ancestry_provider [Proc, nil] Returns ancestors for inheritance lookup
-        def initialize(ancestry_provider: nil)
-          @instance_variables = {} # { "ClassName" => { :@name => WriteNode } }
-          @class_variables = {}    # { "ClassName" => { :@@name => WriteNode } }
-          @ancestry_provider = ancestry_provider
-        end
-
-        # Register an instance variable write
-        # @param class_name [String] Class name
-        # @param name [Symbol] Variable name (e.g., :@recipe)
-        # @param write_node [IR::InstanceVariableWriteNode]
-        def register_instance_variable(class_name, name, write_node)
-          return unless class_name
-
-          @instance_variables[class_name] ||= {}
-          # First write wins (preserves consistent behavior)
-          @instance_variables[class_name][name] ||= write_node
-        end
-
-        # Look up an instance variable write (with inheritance chain traversal)
-        # @param class_name [String]
-        # @param name [Symbol]
-        # @return [IR::InstanceVariableWriteNode, nil]
-        def lookup_instance_variable(class_name, name)
-          return nil unless class_name
-
-          # Try current class first
-          result = @instance_variables.dig(class_name, name)
-          return result if result
-
-          # Traverse ancestor chain if provider available
-          return nil unless @ancestry_provider
-
-          ancestors = @ancestry_provider.call(class_name)
-          ancestors.each do |ancestor_name|
-            next if ancestor_name == class_name # Skip self
-
-            result = @instance_variables.dig(ancestor_name, name)
-            return result if result
-          end
-
-          nil
-        end
-
-        # Register a class variable write
-        # @param class_name [String]
-        # @param name [Symbol] (e.g., :@@count)
-        # @param write_node [IR::ClassVariableWriteNode]
-        def register_class_variable(class_name, name, write_node)
-          return unless class_name
-
-          @class_variables[class_name] ||= {}
-          # First write wins
-          @class_variables[class_name][name] ||= write_node
-        end
-
-        # Look up a class variable write
-        # @param class_name [String]
-        # @param name [Symbol]
-        # @return [IR::ClassVariableWriteNode, nil]
-        def lookup_class_variable(class_name, name)
-          return nil unless class_name
-
-          @class_variables.dig(class_name, name)
-        end
-
-        # Clear all registered variables
-        def clear
-          @instance_variables.clear
-          @class_variables.clear
-        end
-      end
-    end
-  end
-end

data/lib/type_guessr/core/signature_provider.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "types"
-
-module TypeGuessr
-  module Core
-    # SignatureProvider aggregates multiple type sources for method signature lookups
-    # Uses priority-based resolution: first non-Unknown result wins
-    #
-    # @example
-    #   provider = SignatureProvider.new
-    #   provider.add_provider(ProjectRBSProvider.new, priority: :high)
-    #   provider.add_provider(RBSProvider.instance)
-    #
-    #   return_type = provider.get_method_return_type("String", "upcase")
-    class SignatureProvider
-      # @param providers [Array<#get_method_return_type>] Providers in priority order (first = highest)
-      def initialize(providers = [])
-        @providers = providers.dup
-      end
-
-      # Add a provider to the chain
-      # @param provider [#get_method_return_type] Provider implementing the signature protocol
-      # @param priority [:high, :low] Priority level (:high = first, :low = last)
-      def add_provider(provider, priority: :low)
-        case priority
-        when :high
-          @providers.unshift(provider)
-        when :low
-          @providers.push(provider)
-        end
-      end
-
-      # Get instance method return type with overload resolution
-      # @param class_name [String] Class name (e.g., "String", "Array")
-      # @param method_name [String] Method name (e.g., "upcase", "map")
-      # @param arg_types [Array<Types::Type>] Argument types for overload matching
-      # @return [Types::Type] Return type (Unknown if not found in any provider)
-      def get_method_return_type(class_name, method_name, arg_types = [])
-        @providers.each do |provider|
-          result = provider.get_method_return_type(class_name, method_name, arg_types)
-          return result unless result.is_a?(Types::Unknown)
-        end
-        Types::Unknown.instance
-      end
-
-      # Get class method return type (e.g., File.read, Array.new)
-      # @param class_name [String] Class name
-      # @param method_name [String] Method name
-      # @param arg_types [Array<Types::Type>] Argument types for overload matching
-      # @return [Types::Type] Return type (Unknown if not found in any provider)
-      def get_class_method_return_type(class_name, method_name, arg_types = [])
-        @providers.each do |provider|
-          result = provider.get_class_method_return_type(class_name, method_name, arg_types)
-          return result unless result.is_a?(Types::Unknown)
-        end
-        Types::Unknown.instance
-      end
-
-      # Get block parameter types for a method
-      # @param class_name [String] Class name
-      # @param method_name [String] Method name
-      # @return [Array<Types::Type>] Block parameter types (empty if no block or not found)
-      def get_block_param_types(class_name, method_name)
-        @providers.each do |provider|
-          result = provider.get_block_param_types(class_name, method_name)
-          return result unless result.empty?
-        end
-        []
-      end
-
-      # Get method signatures for hover display
-      # @param class_name [String] Class name
-      # @param method_name [String] Method name
-      # @return [Array<Signature>] Method signatures (empty if not found)
-      def get_method_signatures(class_name, method_name)
-        @providers.each do |provider|
-          next unless provider.respond_to?(:get_method_signatures)
-
-          result = provider.get_method_signatures(class_name, method_name)
-          return result unless result.empty?
-        end
-        []
-      end
-
-      # Get class method signatures for hover display (e.g., File.exist?, Dir.pwd)
-      # @param class_name [String] Class name
-      # @param method_name [String] Method name
-      # @return [Array<Signature>] Method signatures (empty if not found)
-      def get_class_method_signatures(class_name, method_name)
-        @providers.each do |provider|
-          next unless provider.respond_to?(:get_class_method_signatures)
-
-          result = provider.get_class_method_signatures(class_name, method_name)
-          return result unless result.empty?
-        end
-        []
-      end
-    end
-  end
-end