type-guessr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 896566907c498dda0251546023a2d6cd8431cc8fdb5f7cbb72c6ef902067d95a
+  data.tar.gz: a8104ed21dff5b62e066223b7fe3a9ff4f9f8b49a5ae2296bd9537a86478d07c
+SHA512:
+  metadata.gz: d0823d8578c5d00d9475f1473349b1ec9aeb96e3e025907a00b933b1e4b32f04663e2e1fe26df0977565d224d54eae4c9a355011826bc8ba2b56496a7750dd3a
+  data.tar.gz: 02000caaf827f2e0297a80ae7296261b4d803e7f49ba8a64d114733dfdea82e079ee5967e9a7c02a311538d095b1fc25bbf3784db4c0a8d5a1be46cac7a5c24a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/riseshia/type-guessr)
+
+# TypeGuessr
+
+> **Warning**: This project is under active development. Breaking changes may occur without notice.
+>
+> CHANGELOG will be maintained once the project reaches a stable phase. Until then, please refer to the commit history.
+
+A Ruby LSP addon that provides heuristic type inference to enhance IDE features like Hover and Go to Definition.
+
+## Features
+
+- **Type Inference**: Automatically infers variable types based on method call patterns
+- **Hover Tooltips**: Shows guessed types when hovering over variables
+- **Heuristic Approach**: Works without type annotations by analyzing method usage
+- **Smart Matching**: Finds classes that have all the methods called on a variable
+
+## Installation
+
+TypeGuessr is a Ruby LSP addon. Add it to your project's Gemfile under the development group:
+
+```ruby
+group :development do
+  gem 'type-guessr', require: false
+end
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+After installation, restart your editor or reload the Ruby LSP server to activate the addon.
+
+## Usage
+
+Once installed, the addon will automatically be loaded by Ruby LSP. Hover over variables, parameters, or instance variables to see guessed types.
+
+### Example
+
+```ruby
+class Recipe
+  def ingredients
+    []
+  end
+
+  def steps
+    []
+  end
+end
+
+def process(recipe)
+  recipe.ingredients  # Hover over 'recipe' shows: Guessed type: Recipe
+  recipe.steps
+end
+```
+
+The addon analyzes method calls (`ingredients`, `steps`) and finds that only the `Recipe` class has both methods, so it infers the type as `Recipe`.
+
+## Configuration
+
+Create a `.type-guessr.yml` file in your project root to customize behavior. See [.type-guessr.yml.example](.type-guessr.yml.example) for all available options.
+
+After changing configuration, restart Ruby LSP (VSCode: reload window).
+
+### Debug Mode
+
+When `debug: true`, the addon will:
+- Log debug information to stderr
+- Show inference basis in hover tooltips
+- Start a debug web server (unless `debug_server: false`)
+
+### Debug Web Server
+
+When enabled, a web server starts at `http://127.0.0.1:<port>` (default port: 7010). This provides a web interface to inspect the type inference:
+
+- **Search**: Search for methods to visualize their IR dependency graphs
+- **Graph Visualization**: Interactive dependency graph
+
+This is useful for understanding how TypeGuessr analyzes your codebase and debugging type inference issues.
+
+## 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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/riseshia/type-guessr.

data/lib/ruby_lsp/type_guessr/addon.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+require_relative "config"
+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
+        "TypeGuessr"
+      end
+
+      def activate(global_state, message_queue)
+        @global_state = global_state
+        @message_queue = message_queue
+        @runtime_adapter = RuntimeAdapter.new(global_state, message_queue)
+        @debug_server = nil
+
+        # 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
+        @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?
+
+        debug_status = Config.debug? ? " (debug mode enabled)" : ""
+        message_queue << RubyLsp::Notification.window_log_message(
+          "[TypeGuessr] Activated#{debug_status}",
+          type: RubyLsp::Constant::MessageType::LOG
+        )
+      end
+
+      def deactivate
+        @runtime_adapter&.restore_type_inferrer
+        @debug_server&.stop
+      end
+
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        return unless Config.enabled?
+
+        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?
+
+        changes.each do |change|
+          uri = URI(change[:uri])
+          next unless uri.path&.end_with?(".rb")
+
+          case change[:type]
+          when RubyLsp::Constant::FileChangeType::CREATED,
+               RubyLsp::Constant::FileChangeType::CHANGED
+            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
+          end
+        end
+      end
+
+      private
+
+      def extend_hover_targets
+        targets = RubyLsp::Listeners::Hover::ALLOWED_TARGETS
+
+        HOVER_TARGET_NODES.each do |target|
+          targets << target unless targets.include?(target)
+        end
+      end
+
+      def reindex_file(uri)
+        file_path = uri.path
+        return unless file_path && File.exist?(file_path)
+
+        source = File.read(file_path)
+        @runtime_adapter.index_source(uri.to_s, source)
+      rescue StandardError => e
+        warn("[TypeGuessr] Error indexing #{uri}: #{e.message}")
+      end
+
+      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)
+        @debug_server.start
+        warn("[TypeGuessr] Debug server started: http://127.0.0.1:#{port}")
+      rescue StandardError => e
+        warn("[TypeGuessr] Failed to start debug server: #{e.class}: #{e.message}")
+        warn("[TypeGuessr] #{e.backtrace&.first(5)&.join("\n")}")
+      end
+    end
+  end
+end

data/lib/ruby_lsp/type_guessr/config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module TypeGuessr
+    # Loads TypeGuessr settings from .type-guessr.yml in the current working directory.
+    #
+    # 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!
+        @cached_config = nil
+        @cached_mtime = nil
+      end
+
+      def enabled?
+        value = load_config.fetch("enabled", true)
+        value != false
+      end
+
+      def debug?
+        load_config["debug"] == true
+      end
+
+      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)
+      end
+
+      def union_cutoff
+        load_config.fetch("union_cutoff", DEFAULT_UNION_CUTOFF)
+      end
+
+      def hash_shape_max_fields
+        load_config.fetch("hash_shape_max_fields", DEFAULT_HASH_SHAPE_MAX_FIELDS)
+      end
+
+      def max_chain_depth
+        load_config.fetch("max_chain_depth", DEFAULT_MAX_CHAIN_DEPTH)
+      end
+
+      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
+
+        require "yaml"
+
+        raw = File.read(path)
+        data = YAML.safe_load(raw, permitted_classes: [], permitted_symbols: [], aliases: false)
+        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
+        {
+          "enabled" => true,
+          "debug" => false
+        }
+      end
+      private_class_method :default_config
+    end
+  end
+end