type-guessr 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 896566907c498dda0251546023a2d6cd8431cc8fdb5f7cbb72c6ef902067d95a
-  data.tar.gz: a8104ed21dff5b62e066223b7fe3a9ff4f9f8b49a5ae2296bd9537a86478d07c
+  metadata.gz: fde9ec92176bfee761b076af417d5bd417720c0535f1171ed39005a4dfb7ff5f
+  data.tar.gz: 6c99963862f3304fc4e616c8d823a6df9defd0d5d4a71176d2b5fecee696d14c
 SHA512:
-  metadata.gz: d0823d8578c5d00d9475f1473349b1ec9aeb96e3e025907a00b933b1e4b32f04663e2e1fe26df0977565d224d54eae4c9a355011826bc8ba2b56496a7750dd3a
-  data.tar.gz: 02000caaf827f2e0297a80ae7296261b4d803e7f49ba8a64d114733dfdea82e079ee5967e9a7c02a311538d095b1fc25bbf3784db4c0a8d5a1be46cac7a5c24a
+  metadata.gz: bbc08313fbdf2e00d4bcf07bc7208534db02ee4500d3af7ca0fc9f2cb2d501f8365944d8aba549cb4a96112a3217a7d145ee6a6c7e8f21fd2c5b0cde7b5c1902
+  data.tar.gz: 2b0cff3ce05f061d4ff6c6d48da8e34e6ddc5cc60fd7ecfbfc8a455f7ff83551ece15814010329361a7ef13dd4433526ecda84e750db9907f3b36cc21d99ead1

data/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "type-guessr": {
+      "command": "ruby",
+      "args": ["exe/type-guessr", "mcp", "."]
+    }
+  }
+}
+

data/README.md

@@ -80,6 +80,47 @@ When enabled, a web server starts at `http://127.0.0.1:<port>` (default port: 70
 
 This is useful for understanding how TypeGuessr analyzes your codebase and debugging type inference issues.
 
+## MCP Server
+
+TypeGuessr can run as a standalone [MCP](https://modelcontextprotocol.io/) server, exposing its type inference engine to AI tools like Claude Code.
+
+### Setup
+
+Using Claude Code CLI:
+
+```bash
+claude mcp add type-guessr -- bundle exec ruby /path/to/type-guessr/exe/type-guessr mcp
+```
+
+Or add to your project's `.mcp.json` manually:
+
+```json
+{
+  "mcpServers": {
+    "type-guessr": {
+      "command": "bundle",
+      "args": ["exec", "ruby", "/path/to/type-guessr/exe/type-guessr", "mcp"]
+    }
+  }
+}
+```
+
+Or run directly:
+
+```bash
+bundle exec ruby exe/type-guessr mcp [project_path]
+```
+
+If `project_path` is omitted, the current directory is used.
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `infer_type` | Infer the type at a specific file/line/column |
+| `get_method_signature` | Get the inferred signature of a method |
+| `search_methods` | Search for method definitions by name or pattern |
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/exe/type-guessr

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+command = ARGV[0]
+
+case command
+when "mcp"
+  project_path = ARGV[1] || Dir.pwd
+  require_relative "../lib/type_guessr/mcp/server"
+  server = TypeGuessr::MCP::Server.new(project_path: project_path)
+  server.start
+when "version", "--version", "-v"
+  require_relative "../lib/type_guessr/version"
+  puts "type-guessr #{TypeGuessr::VERSION}"
+when "help", "--help", "-h", nil
+  puts <<~USAGE
+    Usage: type-guessr <command> [options]
+
+    Commands:
+      mcp [project_path]   Start MCP server for the given project (default: current directory)
+      version              Show version
+      help                 Show this help
+  USAGE
+else
+  warn "Unknown command: #{command}"
+  warn "Run 'type-guessr help' for usage"
+  exit 1
+end

data/lib/ruby_lsp/type_guessr/addon.rb

@@ -2,43 +2,16 @@
 
 require "ruby_lsp/addon"
 require_relative "config"
+require_relative "constants"
 require_relative "runtime_adapter"
 require_relative "hover"
 require_relative "debug_server"
-require_relative "../../type_guessr/core/rbs_provider"
 
 module RubyLsp
   module TypeGuessr
     # TypeGuessr addon for Ruby LSP
     # Provides heuristic type inference without requiring type annotations
     class Addon < ::RubyLsp::Addon
-      # Node types to add to Ruby LSP's ALLOWED_TARGETS for hover support
-      HOVER_TARGET_NODES = [
-        Prism::LocalVariableReadNode,
-        Prism::LocalVariableWriteNode,
-        Prism::LocalVariableTargetNode,
-        Prism::InstanceVariableReadNode,
-        Prism::InstanceVariableWriteNode,
-        Prism::InstanceVariableTargetNode,
-        Prism::ClassVariableReadNode,
-        Prism::ClassVariableWriteNode,
-        Prism::ClassVariableTargetNode,
-        Prism::GlobalVariableReadNode,
-        Prism::GlobalVariableWriteNode,
-        Prism::GlobalVariableTargetNode,
-        Prism::SelfNode,
-        Prism::RequiredParameterNode,
-        Prism::OptionalParameterNode,
-        Prism::RestParameterNode,
-        Prism::RequiredKeywordParameterNode,
-        Prism::OptionalKeywordParameterNode,
-        Prism::KeywordRestParameterNode,
-        Prism::BlockParameterNode,
-        Prism::ForwardingParameterNode,
-        Prism::CallNode,
-        Prism::DefNode,
-      ].freeze
-
       attr_reader :runtime_adapter
 
       def name
@@ -46,6 +19,14 @@ module RubyLsp
       end
 
       def activate(global_state, message_queue)
+        unless Config.enabled?
+          message_queue << RubyLsp::Notification.window_log_message(
+            "[TypeGuessr] Disabled via config",
+            type: RubyLsp::Constant::MessageType::LOG
+          )
+          return
+        end
+
         @global_state = global_state
         @message_queue = message_queue
         @runtime_adapter = RuntimeAdapter.new(global_state, message_queue)
@@ -54,10 +35,7 @@ module RubyLsp
         # Extend Ruby LSP's hover targets to include variables and parameters
         extend_hover_targets
 
-        # Preload RBS environment
-        ::TypeGuessr::Core::RBSProvider.instance.preload
-
-        # Start background indexing
+        # Start indexing (RBS preload, member_index, project files, gem cache)
         @runtime_adapter.start_indexing
 
         # Swap TypeInferrer for enhanced Go to Definition
@@ -79,14 +57,14 @@ module RubyLsp
       end
 
       def create_hover_listener(response_builder, node_context, dispatcher)
-        return unless Config.enabled?
+        return unless @runtime_adapter
 
         Hover.new(@runtime_adapter, response_builder, node_context, dispatcher, @global_state)
       end
 
       # Handle file changes
       def workspace_did_change_watched_files(changes)
-        return unless Config.enabled?
+        return unless @runtime_adapter
 
         changes.each do |change|
           uri = URI(change[:uri])
@@ -98,22 +76,20 @@ module RubyLsp
             reindex_file(uri)
           when RubyLsp::Constant::FileChangeType::DELETED
             file_path = uri.to_standardized_path
-            @runtime_adapter.instance_variable_get(:@location_index).remove_file(file_path) if file_path
+            @runtime_adapter.remove_indexed_file(file_path) if file_path
           end
         end
       end
 
-      private
-
-      def extend_hover_targets
+      private def extend_hover_targets
         targets = RubyLsp::Listeners::Hover::ALLOWED_TARGETS
 
-        HOVER_TARGET_NODES.each do |target|
+        Constants::HOVER_NODE_MAPPING.each_value do |target|
           targets << target unless targets.include?(target)
         end
       end
 
-      def reindex_file(uri)
+      private def reindex_file(uri)
         file_path = uri.path
         return unless file_path && File.exist?(file_path)
 
@@ -123,7 +99,7 @@ module RubyLsp
         warn("[TypeGuessr] Error indexing #{uri}: #{e.message}")
       end
 
-      def start_debug_server
+      private def start_debug_server
         port = Config.debug_server_port
         warn("[TypeGuessr] Starting debug server on port #{port}...")
         @debug_server = DebugServer.new(@global_state, @runtime_adapter, port: port)

data/lib/ruby_lsp/type_guessr/code_index_adapter.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module TypeGuessr
+    # Adapter wrapping RubyIndexer for Core layer consumption
+    # Provides a stable interface isolating RubyIndexer API changes
+    class CodeIndexAdapter
+      # Public instance methods of Object (BasicObject + Kernel).
+      # Every class inherits these, so they have zero discriminating power
+      # for duck-type candidate search and should be excluded.
+      OBJECT_METHOD_NAMES = %w[
+        ! != !~ == === <=>
+        __id__ __send__
+        class clone define_singleton_method display dup
+        enum_for eql? equal? extend
+        freeze frozen? hash inspect
+        instance_of? instance_variable_defined?
+        instance_variable_get instance_variable_set instance_variables
+        is_a? itself kind_of?
+        method methods nil? object_id
+        private_methods protected_methods public_method public_methods public_send
+        remove_instance_variable respond_to? respond_to_missing?
+        send singleton_class singleton_method singleton_methods
+        tap then to_enum to_s yield_self
+      ].to_set.freeze
+
+      def initialize(index)
+        @index = index
+        @member_index = nil        # { method_name => [Entry] }
+        @member_index_files = nil  # { file_path => [Entry] } for removal
+        @method_classes = nil      # { method_name => Set[class_name] } including inherited
+      end
+
+      # Build reverse index: method_name → [Entry::Member]
+      # Also builds @method_classes: method_name → Set[class_name] including inherited methods.
+      # One-time full scan of index entries, called after initial indexing.
+      # Uses keys snapshot + point lookups to avoid Hash iteration conflict
+      # with concurrent Index#add on the main LSP thread.
+      def build_member_index!
+        return unless @index
+
+        mi = Hash.new { |h, k| h[k] = [] }
+        fi = Hash.new { |h, k| h[k] = [] }
+        # owner_name → [method_name] for ancestor expansion
+        owner_methods = Hash.new { |h, k| h[k] = [] }
+
+        entries_hash = @index.instance_variable_get(:@entries)
+        keys = entries_hash.keys # atomic snapshot under GIL
+
+        keys.each do |name|
+          (entries_hash[name] || []).each do |entry|
+            next unless entry.is_a?(RubyIndexer::Entry::Member) && entry.owner
+
+            mi[entry.name] << entry
+            fp = entry.file_path
+            fi[fp] << entry if fp
+
+            owner_methods[entry.owner.name] << entry.name unless OBJECT_METHOD_NAMES.include?(entry.name)
+          end
+        end
+
+        @member_index = mi
+        @member_index_files = fi
+        @method_classes = build_method_classes(owner_methods)
+      end
+
+      # Incrementally update member_index for a single file.
+      # Must be called AFTER RubyIndexer has re-indexed the file.
+      # @param file_uri [URI::Generic] File URI (same format as RubyIndexer entries)
+      def refresh_member_index!(file_uri)
+        return unless @member_index
+
+        file_path = file_uri.respond_to?(:full_path) ? file_uri.full_path : file_uri.path
+
+        # Remove old entries
+        old_entries = @member_index_files.delete(file_path) || []
+        old_entries.each { |entry| @member_index[entry.name]&.delete(entry) }
+
+        # Add new entries from RubyIndexer
+        new_entries = @index.entries_for(file_uri, RubyIndexer::Entry::Member) || []
+        new_entries = new_entries.select(&:owner)
+        new_entries.each { |entry| @member_index[entry.name] << entry }
+        @member_index_files[file_path] = new_entries unless new_entries.empty?
+
+        # Rebuild method_classes from updated member_index
+        rebuild_method_classes! if @method_classes
+      end
+
+      # Get all member entries indexed for a specific file
+      # @param file_path [String] Absolute file path
+      # @return [Array<RubyIndexer::Entry::Member>] Member entries for the file
+      def member_entries_for_file(file_path)
+        return [] unless @member_index_files
+
+        @member_index_files[file_path] || []
+      end
+
+      # Find classes that define ALL given methods (intersection)
+      # Each element responds to .name and .positional_count (duck typed)
+      # @param called_methods [Array<#name, #positional_count>] Methods to search
+      # @return [Array<String>] Class names defining all methods
+      def find_classes_defining_methods(called_methods)
+        return [] if called_methods.empty?
+        return [] unless @index
+
+        # Exclude Object methods — all classes have them, zero discriminating power
+        called_methods = called_methods.reject { |cm| OBJECT_METHOD_NAMES.include?(cm.name.to_s) }
+        return [] if called_methods.empty?
+
+        # Pivot approach: 1 lookup + (N-1) resolve_method calls
+        # Pick the longest method name as pivot (likely most specific → fewest candidates)
+        pivot = called_methods.max_by { |cm| cm.name.to_s.length }
+        rest = called_methods - [pivot]
+
+        # Collect candidates: use @method_classes (includes inherited) when available
+        candidates = if @method_classes
+                       (@method_classes[pivot.name.to_s] || Set.new).to_a
+                     else
+                       entries = if @member_index
+                                   @member_index[pivot.name.to_s] || []
+                                 else
+                                   @index.fuzzy_search(pivot.name.to_s) do |entry|
+                                     entry.is_a?(RubyIndexer::Entry::Member) && entry.name == pivot.name.to_s
+                                   end
+                                 end
+                       entries = filter_by_arity(entries, pivot.positional_count, pivot.keywords) if pivot.positional_count
+                       entries.filter_map do |entry|
+                         entry.owner.name if entry.respond_to?(:owner) && entry.owner
+                       end.uniq
+                     end
+
+        return [] if candidates.empty?
+
+        # When using method_classes, verify pivot arity too (entries-based path already filtered)
+        methods_to_verify = @method_classes ? called_methods : rest
+        return candidates if methods_to_verify.empty?
+
+        # Verify each candidate has ALL methods via resolve_method
+        # resolve_method walks the ancestor chain, so inherited methods are found
+        result = candidates.select do |class_name|
+          methods_to_verify.all? do |cm|
+            method_entries = @index.resolve_method(cm.name.to_s, class_name)
+            next false if method_entries.nil? || method_entries.empty?
+            next true unless cm.positional_count
+
+            method_entries.any? { |e| accepts_arity?(e, cm.positional_count, cm.keywords) }
+          rescue RubyIndexer::Index::NonExistingNamespaceError
+            false
+          end
+        end
+
+        # Prefer non-singleton classes for duck typing.
+        # Singleton classes (e.g., "Foo::<Class:Foo>") represent class objects,
+        # not instances — they match class methods, not instance methods.
+        non_singleton = result.grep_v(/::<Class:[^>]+>\z/)
+        non_singleton.empty? ? result : non_singleton
+      end
+
+      # Get linearized ancestor chain for a class
+      # @param class_name [String] Fully qualified class name
+      # @return [Array<String>] Ancestor names in MRO order
+      def ancestors_of(class_name)
+        return [] unless @index
+
+        @index.linearized_ancestors_of(class_name)
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        []
+      end
+
+      # Get kind of a constant
+      # @param constant_name [String] Fully qualified constant name
+      # @return [Symbol, nil] :class, :module, or nil
+      def constant_kind(constant_name)
+        return nil unless @index
+
+        entries = @index[constant_name]
+        return nil if entries.nil? || entries.empty?
+
+        case entries.first
+        when RubyIndexer::Entry::Class then :class
+        when RubyIndexer::Entry::Module then :module
+        end
+      end
+
+      # Look up owner of a class method
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @return [String, nil] Owner name or nil
+      def class_method_owner(class_name, method_name)
+        return nil unless @index
+
+        unqualified_name = ::TypeGuessr::Core::IR.extract_last_name(class_name)
+        singleton_name = "#{class_name}::<Class:#{unqualified_name}>"
+        entries = @index.resolve_method(method_name, singleton_name)
+        return nil if entries.nil? || entries.empty?
+
+        entries.first.owner&.name
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        nil
+      end
+
+      # Resolve a short constant name to its fully qualified name using nesting context
+      # @param short_name [String] Short constant name (e.g., "RuntimeAdapter")
+      # @param nesting [Array<String>] Nesting context (e.g., ["RubyLsp", "TypeGuessr"])
+      # @return [String, nil] Fully qualified name or nil if not found
+      def resolve_constant_name(short_name, nesting)
+        return nil unless @index
+
+        entries = @index.resolve(short_name, nesting)
+        entries&.first&.name
+      rescue StandardError
+        nil
+      end
+
+      # Look up file path where a method is defined
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @param singleton [Boolean] true for class methods
+      # @return [String, nil] File path or nil if not found
+      def method_definition_file_path(class_name, method_name, singleton: false)
+        return nil unless @index
+
+        target = if singleton
+                   uq = ::TypeGuessr::Core::IR.extract_last_name(class_name)
+                   "#{class_name}::<Class:#{uq}>"
+                 else
+                   class_name
+                 end
+        entries = @index.resolve_method(method_name, target)
+        entries&.first&.file_path
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        nil
+      end
+
+      # Look up owner of an instance method
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @return [String, nil] Owner name or nil
+      def instance_method_owner(class_name, method_name)
+        return nil unless @index
+
+        entries = @index.resolve_method(method_name, class_name)
+        return nil if entries.nil? || entries.empty?
+
+        entries.first.owner&.name
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        nil
+      end
+
+      # Rebuild @method_classes from current @member_index state.
+      private def rebuild_method_classes!
+        owner_methods = {}
+        @member_index.each do |method_name, entries|
+          next if OBJECT_METHOD_NAMES.include?(method_name)
+
+          entries.each do |entry|
+            next unless entry.owner
+
+            (owner_methods[entry.owner.name] ||= []) << method_name
+          end
+        end
+        @method_classes = build_method_classes(owner_methods)
+      end
+
+      # Build method_name → Set[class_name] including inherited methods via ancestor chain.
+      # @param owner_methods [Hash{String => Array<String>}] owner_name → [method_names]
+      # @return [Hash{String => Set<String>}] method_name → Set[class_name]
+      private def build_method_classes(owner_methods)
+        mc = Hash.new { |h, k| h[k] = Set.new }
+
+        # Register direct definitions
+        owner_methods.each do |owner_name, method_names|
+          method_names.each { |mn| mc[mn] << owner_name }
+        end
+
+        # Expand with inherited: for each class, walk ancestors and register child under ancestor's methods
+        # Use .keys snapshot to avoid "can't add a new key during iteration"
+        owner_methods.keys.each do |class_name|
+          ancestors = @index.linearized_ancestors_of(class_name)
+          ancestors.drop(1).each do |ancestor_name|
+            next unless owner_methods.key?(ancestor_name)
+
+            owner_methods[ancestor_name].each do |method_name|
+              mc[method_name] << class_name
+            end
+          end
+        rescue RubyIndexer::Index::NonExistingNamespaceError
+          next
+        end
+
+        mc
+      end
+
+      private def filter_by_arity(entries, count, keywords)
+        entries.select { |entry| accepts_arity?(entry, count, keywords) }
+      end
+
+      private def accepts_arity?(entry, count, keywords)
+        sigs = entry.signatures
+        # Accessor (reader) has no signatures → accepts 0 arguments only
+        return count.zero? && keywords.empty? if sigs.empty?
+
+        sigs.any? do |sig|
+          required = 0
+          optional = 0
+          has_rest = false
+          has_keyword_params = false
+
+          sig.parameters.each do |p|
+            case p
+            when RubyIndexer::Entry::RequiredParameter then required += 1
+            when RubyIndexer::Entry::OptionalParameter then optional += 1
+            when RubyIndexer::Entry::RestParameter then has_rest = true
+            when RubyIndexer::Entry::KeywordParameter,
+                 RubyIndexer::Entry::OptionalKeywordParameter,
+                 RubyIndexer::Entry::KeywordRestParameter
+              has_keyword_params = true
+            end
+          end
+
+          # When call has keywords but method has no keyword params,
+          # keywords are implicitly converted to a Hash positional argument
+          effective_count = count
+          effective_count += 1 if keywords.any? && !has_keyword_params
+
+          if has_rest
+            effective_count >= required
+          else
+            effective_count.between?(required, required + optional)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/type_guessr/config.rb

@@ -7,62 +7,49 @@ module RubyLsp
     # 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