type-guessr 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 896566907c498dda0251546023a2d6cd8431cc8fdb5f7cbb72c6ef902067d95a
-  data.tar.gz: a8104ed21dff5b62e066223b7fe3a9ff4f9f8b49a5ae2296bd9537a86478d07c
+  metadata.gz: 8ff8e62640844d1f305406b2ecf2c67d139e20aa1710e245b9650ce89f051c2d
+  data.tar.gz: ce2659a63614befd227cd54e2755dcda8a32dfd88640665b09101d97cc211071
 SHA512:
-  metadata.gz: d0823d8578c5d00d9475f1473349b1ec9aeb96e3e025907a00b933b1e4b32f04663e2e1fe26df0977565d224d54eae4c9a355011826bc8ba2b56496a7750dd3a
-  data.tar.gz: 02000caaf827f2e0297a80ae7296261b4d803e7f49ba8a64d114733dfdea82e079ee5967e9a7c02a311538d095b1fc25bbf3784db4c0a8d5a1be46cac7a5c24a
+  metadata.gz: b075460f82c3d9a9046e5b2e6ca87173fe84dd62244f240654bea83a7afbb4f1de785d53b2907030b37d6bdd4004a68fda4ca38a2ce4ea1e2720ed5534d30a32
+  data.tar.gz: 80468b024537670450a638f51cfae739ef1efe68227b89c675f095d9ecf1e57dbf648d65f15526f8cce8b5a9d2b9e74313c5f9dc7da9191e5221a2c4f9f6517b

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 type-guessr mcp
+```
+
+Or add to your project's `.mcp.json` manually:
+
+```json
+{
+  "mcpServers": {
+    "type-guessr": {
+      "command": "bundle",
+      "args": ["exec", "type-guessr", "mcp"]
+    }
+  }
+}
+```
+
+Or run directly:
+
+```bash
+bundle exec 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

@@ -1,44 +1,16 @@
 # frozen_string_literal: true
 
 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 +18,14 @@ module RubyLsp
       end
 
       def activate(global_state, message_queue)
+        unless ::TypeGuessr::Core::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,19 +34,16 @@ 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
         @runtime_adapter.swap_type_inferrer
 
         # Start debug server if enabled
-        start_debug_server if Config.debug_server_enabled?
+        start_debug_server if ::TypeGuessr::Core::Config.debug_server_enabled?
 
-        debug_status = Config.debug? ? " (debug mode enabled)" : ""
+        debug_status = ::TypeGuessr::Core::Config.debug? ? " (debug mode enabled)" : ""
         message_queue << RubyLsp::Notification.window_log_message(
           "[TypeGuessr] Activated#{debug_status}",
           type: RubyLsp::Constant::MessageType::LOG
@@ -79,14 +56,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 +75,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,8 +98,8 @@ module RubyLsp
         warn("[TypeGuessr] Error indexing #{uri}: #{e.message}")
       end
 
-      def start_debug_server
-        port = Config.debug_server_port
+      private def start_debug_server
+        port = ::TypeGuessr::Core::Config.debug_server_port
         warn("[TypeGuessr] Starting debug server on port #{port}...")
         @debug_server = DebugServer.new(@global_state, @runtime_adapter, port: port)
         @debug_server.start

data/lib/ruby_lsp/type_guessr/code_index_adapter.rb

@@ -0,0 +1,352 @@
+# 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
+
+      # Inject a custom method into the duck-typing reverse index.
+      # Used by DSL adapters to register framework-generated methods (e.g., AR column accessors).
+      def register_method_class(class_name, method_name)
+        return unless @method_classes
+
+        @method_classes[method_name] ||= Set.new
+        @method_classes[method_name] << class_name
+      end
+
+      # Remove all entries for a class from the duck-typing reverse index.
+      # Used when purging DSL registrations (e.g., schema change).
+      def unregister_method_classes(class_name)
+        return unless @method_classes
+
+        @method_classes.each_value { |set| set.delete(class_name) }
+      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/constants.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RubyLsp
+  module TypeGuessr
+    # Shared constants for TypeGuessr addon
+    module Constants
+      # Mapping from node type symbols to Prism node classes
+      # - keys: Used for dispatcher event handler registration (hover.rb)
+      # - values: Used for extending Ruby LSP's ALLOWED_TARGETS (addon.rb)
+      HOVER_NODE_MAPPING = {
+        local_variable_read: Prism::LocalVariableReadNode,
+        local_variable_write: Prism::LocalVariableWriteNode,
+        local_variable_target: Prism::LocalVariableTargetNode,
+        instance_variable_read: Prism::InstanceVariableReadNode,
+        instance_variable_write: Prism::InstanceVariableWriteNode,
+        instance_variable_target: Prism::InstanceVariableTargetNode,
+        class_variable_read: Prism::ClassVariableReadNode,
+        class_variable_write: Prism::ClassVariableWriteNode,
+        class_variable_target: Prism::ClassVariableTargetNode,
+        global_variable_read: Prism::GlobalVariableReadNode,
+        global_variable_write: Prism::GlobalVariableWriteNode,
+        global_variable_target: Prism::GlobalVariableTargetNode,
+        required_parameter: Prism::RequiredParameterNode,
+        optional_parameter: Prism::OptionalParameterNode,
+        rest_parameter: Prism::RestParameterNode,
+        required_keyword_parameter: Prism::RequiredKeywordParameterNode,
+        optional_keyword_parameter: Prism::OptionalKeywordParameterNode,
+        keyword_rest_parameter: Prism::KeywordRestParameterNode,
+        block_parameter: Prism::BlockParameterNode,
+        forwarding_parameter: Prism::ForwardingParameterNode,
+        call: Prism::CallNode,
+        def: Prism::DefNode,
+        self: Prism::SelfNode
+      }.freeze
+    end
+  end
+end