type-guessr 0.0.2 → 0.0.3

data/lib/type_guessr/mcp/standalone_runtime.rb

@@ -8,8 +8,6 @@ module TypeGuessr
     # Provides type inference, method signature lookup, and method search
     # for use by the MCP server. All public query methods are thread-safe.
     class StandaloneRuntime
-      NodeContextHelper = Core::NodeContextHelper
-
       # @param converter [Core::Converter::PrismConverter]
       # @param location_index [Core::Index::LocationIndex]
       # @param signature_registry [Core::Registry::SignatureRegistry]
@@ -41,6 +39,7 @@ module TypeGuessr
 
         @mutex.synchronize do
           @location_index.remove_file(file_path)
+          @method_registry.remove_file(file_path)
           @resolver.clear_cache
 
           context = Core::Converter::PrismConverter::Context.new(
@@ -62,6 +61,7 @@ module TypeGuessr
       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
@@ -87,38 +87,6 @@ module TypeGuessr
         @signature_registry.preload
       end
 
-      # Infer type at a specific file location
-      # @param file_path [String] Absolute path to the Ruby file
-      # @param line [Integer] Line number (1-based)
-      # @param column [Integer] Column number (0-based)
-      # @return [Hash] Inference result with :type, :reason, :node_type keys, or :error on failure
-      def infer_at(file_path, line, column)
-        file_path = File.expand_path(file_path)
-
-        source = File.read(file_path)
-        parse_result = Prism.parse_lex(source)
-        return { error: "Failed to parse file" } unless parse_result.value
-
-        ast = parse_result.value.first
-        code_units_cache = parse_result.code_units_cache(Encoding::UTF_8)
-
-        char_position = line_column_to_offset(source, line, column)
-        return { error: "Invalid line/column" } unless char_position
-
-        node_context = RubyLsp::RubyDocument.locate(
-          ast,
-          char_position,
-          code_units_cache: code_units_cache
-        )
-
-        prism_node = node_context.node
-        return { error: "No node found at position" } unless prism_node
-
-        infer_from_prism_node(prism_node, node_context)
-      rescue StandardError => e
-        { error: e.message, backtrace: e.backtrace&.first(3) }
-      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")
@@ -132,7 +100,9 @@ module TypeGuessr
           if entry.is_a?(Core::Registry::SignatureRegistry::MethodEntry)
             return {
               source: "rbs",
-              signatures: entry.signature_strings
+              signatures: entry.signature_strings,
+              class_name: class_name,
+              method_name: method_name
             }
           end
 
@@ -145,7 +115,8 @@ module TypeGuessr
             }
           end
 
-          return { error: "Method not found: #{class_name}##{method_name}" }
+          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) }
@@ -156,98 +127,87 @@ module TypeGuessr
           method_name: method_name
         }
       rescue StandardError => e
-        { error: e.message }
+        { 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)
+      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
-
-      private
-
-      # Resolve a Prism AST node to a type inference result
-      # @param prism_node [Prism::Node] The AST node at the cursor position
-      # @param node_context [RubyLsp::NodeContext] Context from RubyDocument.locate
-      # @return [Hash] Inference result
-      private def infer_from_prism_node(prism_node, node_context)
-        exclude_method = prism_node.is_a?(Prism::DefNode)
-        scope_id = NodeContextHelper.generate_scope_id(node_context, exclude_method: exclude_method)
-        node_hash = NodeContextHelper.generate_node_hash(prism_node, node_context)
-        return { error: "Unsupported node type: #{prism_node.class}" } unless node_hash
-
-        node_key = "#{scope_id}:#{node_hash}"
-
-        ir_node = @mutex.synchronize { @location_index.find_by_key(node_key) }
-        return { error: "Node not indexed", node_key: node_key, node_type: prism_node.class.name } unless ir_node
-
-        infer_from_ir_node(ir_node)
-      end
-
-      # Infer type from an IR node, dispatching by node type
-      # @param ir_node [Core::IR::Node] The indexed IR node
-      # @return [Hash] Inference result
-      private def infer_from_ir_node(ir_node)
-        if ir_node.is_a?(Core::IR::DefNode)
-          sig = @mutex.synchronize { @signature_builder.build_from_def_node(ir_node) }
-          return {
-            type: "method_signature",
-            signature: sig.to_s,
-            node_type: "DefNode"
-          }
-        end
-
-        result = @mutex.synchronize { @resolver.infer(ir_node) }
-
-        if ir_node.is_a?(Core::IR::CallNode)
-          {
-            type: result.type.to_s,
-            method: ir_node.method.to_s,
-            reason: result.reason,
-            node_type: "CallNode"
-          }
-        else
-          {
-            type: result.type.to_s,
-            reason: result.reason,
-            node_type: ir_node.class.name.split("::").last
-          }
-        end
-      end
-
-      # Convert 1-based line / 0-based column to byte offset
-      # @param source [String] Source code
-      # @param line [Integer] Line number (1-based)
-      # @param column [Integer] Column number (0-based)
-      # @return [Integer, nil] Byte offset, or nil if line/column is out of bounds
-      private def line_column_to_offset(source, line, column)
-        current_line = 1
-        current_offset = 0
-
-        source.each_char do |char|
-          return current_offset + column if current_line == line
-
-          current_line += 1 if char == "\n"
-          current_offset += char.bytesize
-        end
-
-        # Last line (no trailing newline)
-        current_offset + column if current_line == line
-      end
     end
   end
 end

data/lib/type_guessr/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: type-guessr
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - riseshia
@@ -45,32 +45,52 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".mcp.json"
 - LICENSE
 - README.md
 - exe/type-guessr
 - lib/ruby_lsp/type_guessr/addon.rb
 - lib/ruby_lsp/type_guessr/code_index_adapter.rb
-- lib/ruby_lsp/type_guessr/config.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/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
@@ -104,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/.mcp.json

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