type-guessr 0.0.1 → 0.0.3

data/lib/type_guessr/mcp/server.rb

@@ -0,0 +1,463 @@
+# frozen_string_literal: true
+
+require "json"
+require "prism"
+require "rbs"
+require "mcp"
+require "ruby_indexer/ruby_indexer"
+
+# Load ruby-lsp for RubyDocument.locate and NodeContext
+require "ruby_lsp/internal"
+
+# Load core components
+require_relative "../core"
+
+# Load CodeIndexAdapter, StandaloneRuntime, and FileWatcher
+require_relative "../../ruby_lsp/type_guessr/code_index_adapter"
+require_relative "standalone_runtime"
+require_relative "file_watcher"
+
+module TypeGuessr
+  module MCP
+    # MCP server that exposes type-guessr's inference engine as tools.
+    # Indexes the target project on startup and serves type queries via stdio transport.
+    #
+    # Usage:
+    #   server = TypeGuessr::MCP::Server.new(project_path: "/path/to/project")
+    #   server.start
+    class Server
+      # @return [StandaloneRuntime] The runtime used for inference (available after #start)
+      attr_reader :runtime
+
+      # @param project_path [String] Path to the Ruby project to analyze
+      def initialize(project_path:)
+        @project_path = File.expand_path(project_path)
+        @runtime = nil
+      end
+
+      # Build index and start the MCP server (blocks on stdio transport)
+      def start
+        warn "[type-guessr] Initializing for project: #{@project_path}"
+
+        index = build_ruby_index
+        @runtime = build_runtime(index)
+        index_project_files
+        start_file_watcher
+
+        server = ::MCP::Server.new(
+          name: "type-guessr",
+          version: TypeGuessr::VERSION,
+          tools: build_tools
+        )
+
+        warn "[type-guessr] Server ready"
+        transport = ::MCP::Server::Transports::StdioTransport.new(server)
+        transport.open
+      end
+
+      private def build_ruby_index
+        @ruby_index = Dir.chdir(@project_path) do
+          config = RubyIndexer::Configuration.new
+          index = RubyIndexer::Index.new
+          uris = config.indexable_uris
+          warn "[type-guessr] Indexing #{uris.size} files with RubyIndexer..."
+          index.index_all(uris: uris)
+          index
+        end
+      end
+
+      private def build_runtime(ruby_index)
+        code_index = RubyLsp::TypeGuessr::CodeIndexAdapter.new(ruby_index)
+        signature_registry = Core::Registry::SignatureRegistry.new(code_index: code_index)
+        Core::Registry::SignatureRegistry.instance = signature_registry
+
+        method_registry = Core::Registry::MethodRegistry.new(code_index: code_index)
+        ivar_registry = Core::Registry::InstanceVariableRegistry.new(code_index: code_index)
+        cvar_registry = Core::Registry::ClassVariableRegistry.new
+        type_simplifier = Core::TypeSimplifier.new(code_index: code_index)
+
+        resolver = Core::Inference::Resolver.new(
+          signature_registry,
+          code_index: code_index,
+          method_registry: method_registry,
+          ivar_registry: ivar_registry,
+          cvar_registry: cvar_registry,
+          type_simplifier: type_simplifier
+        )
+
+        StandaloneRuntime.new(
+          converter: Core::Converter::PrismConverter.new,
+          location_index: Core::Index::LocationIndex.new,
+          signature_registry: signature_registry,
+          method_registry: method_registry,
+          ivar_registry: ivar_registry,
+          cvar_registry: cvar_registry,
+          resolver: resolver,
+          signature_builder: Core::SignatureBuilder.new(resolver),
+          code_index: code_index
+        )
+      end
+
+      private def index_project_files
+        config = Dir.chdir(@project_path) { RubyIndexer::Configuration.new }
+        uris = Dir.chdir(@project_path) { config.indexable_uris }
+        file_paths = uris.filter_map do |uri|
+          uri.respond_to?(:to_standardized_path) ? uri.to_standardized_path : uri.path
+        end
+        total = file_paths.size
+
+        # Preload RBS signatures first (needed for gem inference)
+        @runtime.preload_signatures!
+
+        # Build member_index BEFORE gem inference (duck type resolution needs it)
+        @runtime.build_member_index!
+
+        # Try cache-first flow if Gemfile.lock exists
+        lockfile_path = File.join(@project_path, "Gemfile.lock")
+        if File.exist?(lockfile_path)
+          index_with_gem_cache(file_paths, lockfile_path)
+        else
+          index_all_files(file_paths)
+        end
+
+        @runtime.finalize_index!
+        warn "[type-guessr] Indexed #{total} files"
+      end
+
+      # Cache-first indexing: process gems with cache, then project files
+      private def index_with_gem_cache(file_paths, lockfile_path)
+        dep_resolver = Core::Cache::GemDependencyResolver.new(lockfile_path)
+        partitioned = dep_resolver.partition(file_paths)
+        gems = partitioned[:gems]
+        project_files = partitioned[:project_files]
+
+        warn "[type-guessr] Partitioned: #{gems.size} gems, #{project_files.size} project files"
+
+        cache = Core::Cache::GemSignatureCache.new
+        ordered = dep_resolver.topological_order(gems.keys)
+
+        ordered.each do |gem_name|
+          gem_info = gems[gem_name]
+          process_gem(gem_name, gem_info, cache)
+        end
+
+        # Index project files only
+        index_all_files(project_files)
+      end
+
+      # Process a single gem: cache hit → load, cache miss → save unguessed cache
+      private def process_gem(gem_name, gem_info, cache)
+        version = gem_info[:version]
+        deps = gem_info[:transitive_deps]
+        signature_registry = @runtime.instance_variable_get(:@signature_registry)
+        warn "[type-guessr] Processing #{gem_name}-#{version} (#{gem_info[:files].size} files)..."
+
+        if cache.cached?(gem_name, version, deps)
+          data = cache.load(gem_name, version, deps)
+          if data
+            signature_registry.load_gem_cache(data["instance_methods"], kind: :instance)
+            signature_registry.load_gem_cache(data["class_methods"], kind: :class)
+            fully_inferred = data.fetch("fully_inferred", true)
+            warn "[type-guessr] Loaded cached: #{gem_name}-#{version} (fully_inferred=#{fully_inferred})"
+          else
+            warn "[type-guessr] Cache corrupt for #{gem_name}-#{version}, skipping"
+          end
+        else
+          save_unguessed_cache(gem_name, gem_info, cache, signature_registry)
+        end
+      end
+
+      # Infer gem signatures using temporary registries
+      private def infer_and_cache_gem(gem_name, gem_info, cache, signature_registry)
+        version = gem_info[:version]
+        files = gem_info[:files]
+        deps = gem_info[:transitive_deps]
+        code_index = @runtime.instance_variable_get(:@code_index)
+
+        # Phase A: Parse + IR conversion
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        temp_location_index = Core::Index::LocationIndex.new
+        temp_method_registry = Core::Registry::MethodRegistry.new(code_index: code_index)
+        temp_ivar_registry = Core::Registry::InstanceVariableRegistry.new(code_index: code_index)
+        temp_cvar_registry = Core::Registry::ClassVariableRegistry.new
+        converter = Core::Converter::PrismConverter.new
+
+        files.each do |file_path|
+          next unless File.exist?(file_path)
+
+          parsed = Prism.parse(File.read(file_path))
+          next unless parsed.value
+
+          context = Core::Converter::PrismConverter::Context.new(
+            file_path: file_path,
+            location_index: temp_location_index,
+            method_registry: temp_method_registry,
+            ivar_registry: temp_ivar_registry,
+            cvar_registry: temp_cvar_registry
+          )
+          parsed.value.statements&.body&.each { |stmt| converter.convert(stmt, context) }
+        rescue StandardError => e
+          warn "[type-guessr] Error indexing gem file #{file_path}: #{e.message}"
+        end
+        temp_location_index.finalize!
+
+        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # Phase B: Inference (extract signatures)
+        type_simplifier = Core::TypeSimplifier.new(code_index: code_index)
+        temp_resolver = Core::Inference::Resolver.new(
+          signature_registry,
+          code_index: code_index,
+          method_registry: temp_method_registry,
+          ivar_registry: temp_ivar_registry,
+          cvar_registry: temp_cvar_registry,
+          type_simplifier: type_simplifier
+        )
+        temp_builder = Core::SignatureBuilder.new(temp_resolver)
+
+        extractor = Core::Cache::GemSignatureExtractor.new(
+          signature_builder: temp_builder,
+          method_registry: temp_method_registry,
+          location_index: temp_location_index
+        )
+        signatures = extractor.extract(files)
+
+        t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # Phase C: Disk save
+        cache.save(gem_name, version, deps,
+                   instance_methods: signatures[:instance_methods],
+                   class_methods: signatures[:class_methods])
+
+        t3 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # Phase D: Registry load
+        signature_registry.load_gem_cache(signatures[:instance_methods], kind: :instance)
+        signature_registry.load_gem_cache(signatures[:class_methods], kind: :class)
+
+        t4 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        warn "[type-guessr] Cached #{gem_name}-#{version} (#{files.size} files, " \
+             "#{signatures[:instance_methods].size} classes) " \
+             "[parse=#{(t1 - t0).round(2)}s infer=#{(t2 - t1).round(2)}s " \
+             "save=#{(t3 - t2).round(2)}s load=#{(t4 - t3).round(2)}s]"
+      end
+
+      # Generate an Unguessed cache from member_index entries (no parse/infer needed).
+      private def save_unguessed_cache(gem_name, gem_info, cache, signature_registry)
+        version = gem_info[:version]
+        files = gem_info[:files]
+        deps = gem_info[:transitive_deps]
+        code_index = @runtime.instance_variable_get(:@code_index)
+
+        instance_methods = {}
+        class_methods = {}
+
+        files.each do |file_path|
+          code_index.member_entries_for_file(file_path).each do |entry|
+            owner_name = entry.owner.name
+
+            if owner_name.match?(/::<Class:[^>]+>\z/)
+              class_name = extract_class_from_singleton(owner_name)
+              target = class_methods
+            else
+              class_name = owner_name
+              target = instance_methods
+            end
+
+            target[class_name] ||= {}
+            target[class_name][entry.name] = {
+              "return_type" => { "_type" => "Unguessed" },
+              "params" => build_params_from_entry(entry)
+            }
+          end
+        end
+
+        cache.save(gem_name, version, deps,
+                   instance_methods: instance_methods,
+                   class_methods: class_methods,
+                   fully_inferred: false)
+
+        signature_registry.load_gem_cache(instance_methods, kind: :instance)
+        signature_registry.load_gem_cache(class_methods, kind: :class)
+
+        warn "[type-guessr] Saved unguessed cache for #{gem_name}-#{version} " \
+             "(#{instance_methods.size} instance classes, #{class_methods.size} class method classes)"
+      end
+
+      # Extract simple class name from singleton format
+      # "File::<Class:File>" -> "File"
+      private def extract_class_from_singleton(owner_class)
+        if owner_class.match?(/::<Class:[^>]+>\z/)
+          owner_class.sub(/::<Class:[^>]+>\z/, "")
+        else
+          owner_class
+        end
+      end
+
+      # Build serialized params array from a RubyIndexer::Entry::Member
+      private def build_params_from_entry(entry)
+        sigs = entry.signatures
+        return [] if sigs.empty?
+
+        sigs.first.parameters.filter_map do |p|
+          kind = case p
+                 when RubyIndexer::Entry::RequiredParameter then "required"
+                 when RubyIndexer::Entry::OptionalParameter then "optional"
+                 when RubyIndexer::Entry::RestParameter then "rest"
+                 when RubyIndexer::Entry::KeywordParameter then "keyword_required"
+                 when RubyIndexer::Entry::OptionalKeywordParameter then "keyword_optional"
+                 when RubyIndexer::Entry::KeywordRestParameter then "keyword_rest"
+                 when RubyIndexer::Entry::BlockParameter then "block"
+                 else next
+                 end
+          { "name" => p.name.to_s, "kind" => kind, "type" => { "_type" => "Unguessed" } }
+        end
+      end
+
+      # Index files into the main runtime (project files only)
+      private def index_all_files(file_paths)
+        file_paths.each do |file_path|
+          next unless File.exist?(file_path)
+
+          parsed = Prism.parse(File.read(file_path))
+          next unless parsed.value
+
+          @runtime.index_parsed_file(file_path, parsed)
+        rescue StandardError => e
+          warn "[type-guessr] Error indexing #{file_path}: #{e.message}"
+        end
+      end
+
+      private def start_file_watcher
+        @file_watcher = FileWatcher.new(
+          project_path: @project_path,
+          on_change: method(:handle_file_changes)
+        )
+        @file_watcher.start
+        warn "[type-guessr] File watcher started (polling every 2s)"
+      end
+
+      private def handle_file_changes(modified, added, removed)
+        (modified + added).each do |file_path|
+          source = File.read(file_path)
+          uri = URI::Generic.from_path(path: file_path)
+          parsed = Prism.parse(source)
+          @ruby_index.handle_change(uri, source)
+          @runtime.index_parsed_file(file_path, parsed)
+          @runtime.refresh_member_index!(uri)
+          warn "[type-guessr] Re-indexed: #{file_path}"
+        rescue StandardError => e
+          warn "[type-guessr] Error re-indexing #{file_path}: #{e.message}"
+        end
+
+        removed.each do |file_path|
+          uri = URI::Generic.from_path(path: file_path)
+          @ruby_index.delete(uri)
+          @runtime.remove_indexed_file(file_path)
+          @runtime.refresh_member_index!(uri)
+          warn "[type-guessr] Removed from index: #{file_path}"
+        end
+      end
+
+      private def build_tools
+        [build_get_method_sources_tool, build_get_method_signatures_tool, build_search_methods_tool]
+      end
+
+      private def build_get_method_sources_tool
+        runtime = @runtime
+        to_response = method(:json_response)
+
+        ::MCP::Tool.define(
+          name: "get_method_sources",
+          description: "Get source code of methods by class and method name. " \
+                       "Returns the full method definition with file path and line number. " \
+                       "Use when you need to read a method's implementation without knowing " \
+                       "the exact file location.",
+          input_schema: {
+            type: "object",
+            properties: {
+              methods: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    class_name: { type: "string", description: "Fully qualified class name (e.g., 'User', 'Admin::User')" },
+                    method_name: { type: "string", description: "Method name (e.g., 'save', 'initialize')" }
+                  },
+                  required: %w[class_name method_name]
+                },
+                description: "Array of {class_name, method_name} to look up"
+              }
+            },
+            required: %w[methods]
+          }
+        ) do |methods:, **|
+          to_response.call(runtime.method_sources(methods))
+        end
+      end
+
+      private def build_get_method_signatures_tool
+        runtime = @runtime
+        to_response = method(:json_response)
+
+        ::MCP::Tool.define(
+          name: "get_method_signatures",
+          description: "Get inferred signatures for multiple methods in one call. " \
+                       "More efficient than calling get_method_signature repeatedly " \
+                       "when investigating a class or module.",
+          input_schema: {
+            type: "object",
+            properties: {
+              methods: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    class_name: { type: "string", description: "Fully qualified class name" },
+                    method_name: { type: "string", description: "Method name" }
+                  },
+                  required: %w[class_name method_name]
+                },
+                description: "Array of {class_name, method_name} to look up"
+              }
+            },
+            required: %w[methods]
+          }
+        ) do |methods:, **|
+          to_response.call(runtime.method_signatures(methods))
+        end
+      end
+
+      private def build_search_methods_tool
+        runtime = @runtime
+        to_response = method(:json_response)
+
+        ::MCP::Tool.define(
+          name: "search_methods",
+          description: "Search for method definitions across the project with type-aware results. " \
+                       "Returns matching methods with their inferred signatures. Unlike grep, results " \
+                       "include class hierarchy context and inferred types. Supports patterns: " \
+                       "'User#save' (specific), 'save' (all classes), 'Admin::*' (namespace). " \
+                       "Use when exploring an unfamiliar codebase or finding which classes implement " \
+                       "a given method.",
+          input_schema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Search query (e.g., 'User#save', 'save', 'initialize')" },
+              include_signatures: { type: "boolean", description: "Include inferred method signatures in results (default: false)" }
+            },
+            required: %w[query]
+          }
+        ) do |query:, include_signatures: false, **|
+          to_response.call(runtime.search_methods(query, include_signatures: include_signatures))
+        end
+      end
+
+      private def json_response(data)
+        ::MCP::Tool::Response.new([{ type: "text", text: JSON.generate(data) }])
+      end
+    end
+  end
+end

data/lib/type_guessr/mcp/standalone_runtime.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module MCP
+    # Standalone runtime that mirrors RuntimeAdapter's query interface
+    # without depending on ruby-lsp's GlobalState.
+    #
+    # Provides type inference, method signature lookup, and method search
+    # for use by the MCP server. All public query methods are thread-safe.
+    class StandaloneRuntime
+      # @param converter [Core::Converter::PrismConverter]
+      # @param location_index [Core::Index::LocationIndex]
+      # @param signature_registry [Core::Registry::SignatureRegistry]
+      # @param method_registry [Core::Registry::MethodRegistry]
+      # @param ivar_registry [Core::Registry::InstanceVariableRegistry]
+      # @param cvar_registry [Core::Registry::ClassVariableRegistry]
+      # @param resolver [Core::Inference::Resolver]
+      # @param signature_builder [Core::SignatureBuilder]
+      # @param code_index [RubyLsp::TypeGuessr::CodeIndexAdapter]
+      def initialize(converter:, location_index:, signature_registry:, method_registry:,
+                     ivar_registry:, cvar_registry:, resolver:, signature_builder:, code_index:)
+        @converter = converter
+        @location_index = location_index
+        @signature_registry = signature_registry
+        @method_registry = method_registry
+        @ivar_registry = ivar_registry
+        @cvar_registry = cvar_registry
+        @resolver = resolver
+        @signature_builder = signature_builder
+        @code_index = code_index
+        @mutex = Mutex.new
+      end
+
+      # Index a pre-parsed file into the IR graph
+      # @param file_path [String] Absolute path to the file
+      # @param prism_result [Prism::ParseResult] Parsed AST
+      def index_parsed_file(file_path, prism_result)
+        return unless prism_result.value
+
+        @mutex.synchronize do
+          @location_index.remove_file(file_path)
+          @method_registry.remove_file(file_path)
+          @resolver.clear_cache
+
+          context = Core::Converter::PrismConverter::Context.new(
+            file_path: file_path,
+            location_index: @location_index,
+            method_registry: @method_registry,
+            ivar_registry: @ivar_registry,
+            cvar_registry: @cvar_registry
+          )
+
+          prism_result.value.statements&.body&.each do |stmt|
+            @converter.convert(stmt, context)
+          end
+        end
+      end
+
+      # Remove all indexed data for a file
+      # @param file_path [String] Absolute path to the file
+      def remove_indexed_file(file_path)
+        @mutex.synchronize do
+          @location_index.remove_file(file_path)
+          @method_registry.remove_file(file_path)
+          @resolver.clear_cache
+        end
+      end
+
+      # Delegate member_index build to code_index
+      def build_member_index!
+        @code_index.build_member_index!
+      end
+
+      # Delegate member_index refresh to code_index
+      # @param file_uri [URI::Generic] File URI
+      def refresh_member_index!(file_uri)
+        @code_index.refresh_member_index!(file_uri)
+      end
+
+      # Finalize location index after all files are indexed
+      def finalize_index!
+        @mutex.synchronize { @location_index.finalize! }
+      end
+
+      # Preload RBS signatures for inference
+      def preload_signatures!
+        @signature_registry.preload
+      end
+
+      # Get method signature for a class#method
+      # @param class_name [String] Fully qualified class name (e.g., "User", "Admin::User")
+      # @param method_name [String] Method name (e.g., "save", "initialize")
+      # @return [Hash] Signature result with :source and :signature keys, or :error on failure
+      def method_signature(class_name, method_name)
+        def_node = @mutex.synchronize { @method_registry.lookup(class_name, method_name) }
+
+        unless def_node
+          entry = @signature_registry.lookup(class_name, method_name)
+
+          if entry.is_a?(Core::Registry::SignatureRegistry::MethodEntry)
+            return {
+              source: "rbs",
+              signatures: entry.signature_strings,
+              class_name: class_name,
+              method_name: method_name
+            }
+          end
+
+          if entry.is_a?(Core::Registry::SignatureRegistry::GemMethodEntry)
+            return {
+              source: "gem_cache",
+              signatures: entry.signature_strings,
+              class_name: class_name,
+              method_name: method_name
+            }
+          end
+
+          return { error: "Method not found: #{class_name}##{method_name}", class_name: class_name,
+                   method_name: method_name }
+        end
+
+        sig = @mutex.synchronize { @signature_builder.build_from_def_node(def_node) }
+        {
+          source: "project",
+          signature: sig.to_s,
+          class_name: class_name,
+          method_name: method_name
+        }
+      rescue StandardError => e
+        { error: e.message, class_name: class_name, method_name: method_name }
+      end
+
+      # Get signatures for multiple methods in one call
+      # @param methods [Array<Hash>] Array of { class_name:, method_name: } hashes
+      # @return [Array<Hash>] Array of signature results (same format as method_signature)
+      def method_signatures(methods)
+        methods.map do |entry|
+          method_signature(entry[:class_name], entry[:method_name])
+        end
+      end
+
+      # Get source code for a single method
+      # @param class_name [String] Fully qualified class name
+      # @param method_name [String] Method name
+      # @return [Hash] Source result with :source, :file_path, :line keys, or :error on failure
+      def method_source(class_name, method_name)
+        def_node = @mutex.synchronize { @method_registry.lookup(class_name, method_name) }
+        unless def_node
+          return { error: "Method not found: #{class_name}##{method_name}",
+                   class_name: class_name, method_name: method_name }
+        end
+
+        file_path = @mutex.synchronize { @method_registry.source_file_for(class_name, method_name) }
+        unless file_path
+          return { error: "Source file not found: #{class_name}##{method_name}",
+                   class_name: class_name, method_name: method_name }
+        end
+
+        source = File.read(file_path)
+        prism_result = Prism.parse(source)
+        node_context = RubyLsp::RubyDocument.locate(
+          prism_result.value, def_node.loc,
+          code_units_cache: prism_result.code_units_cache(Encoding::UTF_8)
+        )
+        prism_def = node_context.node.is_a?(Prism::DefNode) ? node_context.node : node_context.parent
+
+        {
+          class_name: class_name,
+          method_name: method_name,
+          source: prism_def.slice,
+          file_path: file_path,
+          line: prism_def.location.start_line
+        }
+      rescue StandardError => e
+        { error: e.message, class_name: class_name, method_name: method_name }
+      end
+
+      # Get source code for multiple methods in one call
+      # @param methods [Array<Hash>] Array of { class_name:, method_name: } hashes
+      # @return [Array<Hash>] Array of source results (same format as method_source)
+      def method_sources(methods)
+        methods.map do |entry|
+          method_source(entry[:class_name], entry[:method_name])
+        end
+      end
+
+      # Search for methods matching a query pattern
+      # @param query [String] Search query (e.g., "User#save", "save", "initialize")
+      # @param include_signatures [Boolean] When true, include inferred signature for each result
+      # @return [Array<Hash>] Array of matching methods with :class_name, :method_name, :full_name, :location
+      def search_methods(query, include_signatures: false)
+        @mutex.synchronize do
+          results = @method_registry.search(query)
+          results.map do |class_name, method_name, def_node|
+            entry = {
+              class_name: class_name,
+              method_name: method_name,
+              full_name: "#{class_name}##{method_name}",
+              location: def_node.loc ? { offset: def_node.loc } : nil
+            }
+            if include_signatures
+              sig = @signature_builder.build_from_def_node(def_node)
+              entry[:signature] = sig.to_s
+            end
+            entry
+          end
+        end
+      rescue StandardError => e
+        { error: e.message }
+      end
+    end
+  end
+end

data/lib/type_guessr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypeGuessr
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end