mui-lsp 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 265b2178245c88fe87ea19d4b97323cd4bc47cc104ed89258fed1e542d6c2c57
-  data.tar.gz: 762e6e1dcb1dc49f22bf866647b9a2c7637806e16d1f8070b46a899290db93f1
+  metadata.gz: 263fd9cae12708ea5be41993083794357068d8af592bc9b7684f650cd9eb094d
+  data.tar.gz: 14d542c5978a50e0095acd951a418e43445208a7907024df7eb4dff8ead2e499
 SHA512:
-  metadata.gz: b20c948e1fe4171cf1a87db8d738f758375f5094b2463c64dbe3b9ed6c803fb666f5692158516d543b62acbed82cb1bfe5103a6224a4d2fb7435daaa124b14da
-  data.tar.gz: a24ed8994311f2db029ef9a9cde459a27fe9669eff27f332f60fedc7e51838d9647a37f40e61e2b2ba8e3707d5b84c6ff51237d9725d06d1155632d25f245d1b
+  metadata.gz: 488392ecc54c123a1a558def0e6b8ec326f85252f0ab95bb2dc97fc40f5a864e43a60563578d0e3b817207ae5122bcb1f5350a0cb884db5ea01549a9e42bfcf1
+  data.tar.gz: 8fd6da70ce1e5640e35f72d3d1239d0ec2d5fb76a3e5791a8b406f0efb1b3a3369a16bed112b1ba153d8ec9e96141fdcc0e6a3483470f2faeed10951864b6e26

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-12-11 11:19:34 UTC using RuboCop version 1.81.7.
+# on 2025-12-26 06:52:41 UTC using RuboCop version 1.81.7.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -12,36 +12,54 @@ Lint/DuplicateBranch:
   Exclude:
     - 'lib/mui/lsp/highlighters/diagnostic_highlighter.rb'
 
-# Offense count: 16
+# Offense count: 1
+# Configuration parameters: AllowComments.
+Lint/EmptyClass:
+  Exclude:
+    - 'test/mui/lsp/handlers/test_completion.rb'
+
+# Offense count: 25
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
 Metrics/AbcSize:
-  Max: 44
+  Max: 46
 
-# Offense count: 6
+# Offense count: 8
 # Configuration parameters: CountComments, CountAsOne.
 Metrics/ClassLength:
-  Max: 361
+  Max: 435
 
-# Offense count: 7
+# Offense count: 8
 # Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/CyclomaticComplexity:
   Max: 26
 
-# Offense count: 42
+# Offense count: 83
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
-  Max: 61
+  Max: 56
 
 # Offense count: 4
 # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
 Metrics/ParameterLists:
   Max: 6
 
-# Offense count: 6
+# Offense count: 5
 # Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/PerceivedComplexity:
   Max: 14
 
+# Offense count: 1
+Naming/AccessorMethodName:
+  Exclude:
+    - 'lib/mui/lsp/handlers/completion.rb'
+
+# Offense count: 4
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
+Naming/MethodParameterName:
+  Exclude:
+    - 'test/fixtures/sample.rb'
+
 # Offense count: 2
 # Configuration parameters: Mode, AllowedMethods, AllowedPatterns, AllowBangMethods, WaywardPredicates.
 # AllowedMethods: call
@@ -65,7 +83,7 @@ Style/IfUnlessModifier:
   Exclude:
     - 'lib/mui/lsp/json_rpc_io.rb'
 
-# Offense count: 1
+# Offense count: 4
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, IgnoreCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-12-26 
+
+### Added
+- Multiple LSP result merging:
+  - Definition, References, and Type Definition now query all matching LSP servers
+  - Results from all servers are merged and deduplicated
+  - Enables showing both Ruby source and RBS type definitions together
+- Steep pre-configured server:
+  - `use :steep` in `Mui.lsp` block to enable
+  - Requires `Steepfile` in project root
+  - Supports `.rb` and `.rbs` files
+- Ruby/RBS file toggle (`<Space>tf`):
+  - In Ruby files: jumps to corresponding RBS file in `sig/` directory
+  - In RBS files: jumps to corresponding Ruby file in `lib/` directory
+  - Searches multiple path patterns (e.g., `lib/mui/config.rb` → `sig/mui/config.rbs`)
+  - For non-Ruby files: uses LSP `textDocument/typeDefinition` as before
+- Type definition support (`textDocument/typeDefinition`):
+  - `:LspTypeDefinition` command to jump to type definition
+  - `<Space>tf` keymap for type definition
+  - Works with TypeProf, Sorbet, Steep and other Ruby type checkers
+  - Uses same picker UI as Definition when multiple candidates found
+- TypeProf pre-configured server:
+  - `use :typeprof` in `Mui.lsp` block to enable
+  - Requires `typeprof.conf.jsonc` in project root (run `typeprof --init` to create)
+- Format support (`textDocument/formatting`):
+  - `:LspFormat` command to format current file
+  - `<Space>ff` keymap for formatting
+  - Works with RuboCop LSP and other formatters
+- Location picker for Definition and References:
+  - When multiple definitions or references are found, opens a scratch buffer picker
+  - `j`/`k` - Navigate up/down (native cursor movement)
+  - `\` + `Enter` - Open selected location in current window
+  - `Ctrl+t` - Open selected location in new tab
+  - `\q` / `\` + `Esc` - Close picker
+
+### Fixed
+- Type definition now checks `typeDefinitionProvider` capability before sending requests
+  - Prevents sending requests to servers that don't support type definition (e.g., Solargraph)
+  - Shows helpful message when no server supports type definition
+
+### Changed
+- Keymaps changed from leader key (`\`) to `<Space>` prefix:
+  - `<Space>df` - Go to definition
+  - `<Space>rf` - Find references
+  - `<Space>hf` - Show hover information
+  - `<Space>cf` - Show completion
+  - `<Space>ef` - Show diagnostic at cursor
+- Removed manual `@leader_pending` state management in favor of Mui's native multi-key sequence support
+
 ## [0.2.0] - 2025-12-12
 
 ### Added

data/README.md

@@ -4,10 +4,12 @@ LSP (Language Server Protocol) plugin for [Mui](https://github.com/S-H-GAMELINKS
 
 ## Features
 
-- **Hover**: Show documentation for symbol under cursor (`K` or `\h` or `:LspHover`)
-- **Go to Definition**: Jump to symbol definition (`\d` or `:LspDefinition`)
-- **Find References**: Show all references to symbol (`\r` or `:LspReferences`)
-- **Completion**: Get code completion suggestions (`\c` or `:LspCompletion`)
+- **Hover**: Show documentation for symbol under cursor (`K` or `<Space>hf` or `:LspHover`)
+- **Go to Definition**: Jump to symbol definition (`<Space>df` or `:LspDefinition`)
+- **Go to Type Definition**: Jump to type definition or toggle between Ruby/RBS files (`<Space>tf` or `:LspTypeDefinition`)
+- **Find References**: Show all references to symbol (`<Space>rf` or `:LspReferences`)
+- **Completion**: Get code completion suggestions (`<Space>cf` or `:LspCompletion`)
+- **Format**: Format current file with LSP server (`<Space>ff` or `:LspFormat`)
 - **Diagnostics**: Display errors and warnings from LSP server (`:LspDiagnostics`)
 
 ## Supported Language Servers
@@ -18,6 +20,8 @@ Pre-configured servers for Ruby:
 - **ruby-lsp** - Shopify's Ruby language server
 - **Kanayago** - Realtime Ruby Syntax Check server
 - **RuboCop** (LSP mode) - Ruby linter with LSP support
+- **TypeProf** - Ruby type analysis and inference
+- **Steep** - Ruby type checker with RBS support
 
 Custom servers can be configured for other languages.
 
@@ -59,6 +63,42 @@ Available pre-configured servers:
 - `:ruby_lsp` - ruby-lsp (Shopify's Ruby LSP)
 - `:rubocop` - RuboCop in LSP mode
 - `:kanayago` - Kanayago (Japanese Ruby LSP)
+- `:typeprof` - TypeProf (Ruby type analysis)
+- `:steep` - Steep (Ruby type checker with RBS)
+
+### TypeProf Setup
+
+TypeProf requires a configuration file in your project root. Run:
+
+```bash
+typeprof --init
+```
+
+This creates `typeprof.conf.jsonc` with default settings:
+
+```jsonc
+{
+  "typeprof_version": "experimental",
+  "rbs_dir": "sig/",
+  "analysis_unit_dirs": ["lib"]
+}
+```
+
+TypeProf will only analyze files in the directories specified in `analysis_unit_dirs`. Without this configuration file, TypeProf will not track documents and type definition features will not work.
+
+### Steep Setup
+
+Steep requires a `Steepfile` in your project root. Create one with:
+
+```ruby
+# Steepfile
+target :lib do
+  signature "sig"
+  check "lib"
+end
+```
+
+Place your RBS type definitions in the `sig/` directory.
 
 ### Custom Server Configuration
 
@@ -126,27 +166,40 @@ To manually start a server:
 | `:LspStatus` | Show running and registered servers |
 | `:LspHover` | Show hover information |
 | `:LspDefinition` | Go to definition |
+| `:LspTypeDefinition` | Go to type definition |
 | `:LspReferences` | Find all references |
 | `:LspCompletion` | Show completion menu |
 | `:LspDiagnostics` | Show diagnostics for current file |
 | `:LspDiagnosticShow` | Show diagnostic at cursor in floating window |
+| `:LspFormat` | Format current file |
 | `:LspLog` | Show LSP server logs in a buffer |
 | `:LspDebug` | Show debug information |
 | `:LspOpen` | Manually notify LSP server about current file |
 
 ### Keymaps
 
-Leader key is `\` (backslash).
-
 | Key | Mode | Description |
 |-----|------|-------------|
 | `K` | Normal | Show hover information (in floating window) |
-| `\h` | Normal | Show hover information (alternative) |
-| `\d` | Normal | Go to definition |
-| `\r` | Normal | Find references |
-| `\c` | Normal | Show completion |
-| `\e` | Normal | Show diagnostic at cursor (in floating window) |
-| `Esc` | Normal | Cancel leader pending state / Close floating window |
+| `<Space>df` | Normal | Go to definition |
+| `<Space>tf` | Normal | Go to type definition (Ruby: toggle .rb/.rbs) |
+| `<Space>rf` | Normal | Find references |
+| `<Space>hf` | Normal | Show hover information (alternative to K) |
+| `<Space>cf` | Normal | Show completion |
+| `<Space>ef` | Normal | Show diagnostic at cursor (in floating window) |
+| `<Space>ff` | Normal | Format current file |
+| `Esc` | Normal | Close floating window / picker |
+
+#### Location Picker (for Definition/References with multiple candidates)
+
+When multiple definitions or references are found, a picker buffer opens. Use standard Vim navigation:
+
+| Key | Description |
+|-----|-------------|
+| `j`/`k` | Navigate up/down (native cursor movement) |
+| `\` + `Enter` | Open selected location in current window |
+| `Ctrl+t` | Open selected location in new tab |
+| `\q` / `\` + `Esc` | Close picker |
 
 ## Architecture
 
@@ -162,9 +215,11 @@ mui-lsp/
       base.rb          # Base handler class
       hover.rb         # Hover response handler
       definition.rb    # Definition response handler
+      type_definition.rb # Type definition response handler
       references.rb    # References response handler
       diagnostics.rb   # Diagnostics notification handler
       completion.rb    # Completion response handler
+      formatting.rb    # Formatting response handler
     json_rpc_io.rb     # JSON-RPC 2.0 over stdio
     request_manager.rb # Request ID and callback management
     server_config.rb   # Server configuration presets

data/lib/mui/lsp/client.rb

@@ -104,6 +104,13 @@ module Mui
                 }, &callback)
       end
 
+      def type_definition(uri:, line:, character:, &callback)
+        request("textDocument/typeDefinition", {
+                  textDocument: { uri: uri },
+                  position: { line: line, character: character }
+                }, &callback)
+      end
+
       def references(uri:, line:, character:, include_declaration: true, &callback)
         request("textDocument/references", {
                   textDocument: { uri: uri },
@@ -119,6 +126,16 @@ module Mui
                 }, &callback)
       end
 
+      def formatting(uri:, tab_size: 2, insert_spaces: true, &callback)
+        request("textDocument/formatting", {
+                  textDocument: { uri: uri },
+                  options: {
+                    tabSize: tab_size,
+                    insertSpaces: insert_spaces
+                  }
+                }, &callback)
+      end
+
       def did_open(uri:, language_id:, version:, text:)
         notify("textDocument/didOpen", {
                  textDocument: {
@@ -270,7 +287,13 @@ module Mui
             definition: {
               linkSupport: false
             },
+            typeDefinition: {
+              linkSupport: false
+            },
             references: {},
+            formatting: {
+              dynamicRegistration: false
+            },
             publishDiagnostics: {
               relatedInformation: true
             },

data/lib/mui/lsp/handlers/completion.rb

@@ -102,7 +102,7 @@ module Mui
 
           # Find word start
           start_col = col
-          start_col -= 1 while start_col > 0 && line[start_col - 1] =~ /\w/
+          start_col -= 1 while start_col.positive? && line[start_col - 1] =~ /\w/
 
           line[start_col...col] || ""
         end

data/lib/mui/lsp/handlers/definition.rb

@@ -83,15 +83,22 @@ module Mui
         end
 
         def show_location_list(locations)
-          # Show a list of locations for the user to choose from
-          items = locations.map do |loc|
+          # Store locations for picker navigation
+          @editor.instance_variable_set(:@lsp_picker_locations, locations)
+          @editor.instance_variable_set(:@lsp_picker_type, :definition)
+
+          # Build picker content
+          lines = []
+          locations.each_with_index do |loc, idx|
             file_path = loc.file_path || loc.uri
-            line = loc.range.start.line + 1
-            "#{file_path}:#{line}"
+            display_path = File.basename(file_path.to_s)
+            line_num = loc.range.start.line + 1
+            lines << "#{idx + 1}. #{display_path}:#{line_num}"
           end
 
-          @editor.message = "Found #{locations.length} definitions: #{items.first}..."
-          # TODO: Integrate with quickfix list or popup menu when available
+          # Open scratch buffer for picker
+          content = "Definitions (\\Enter:open, Ctrl+t:tab, \\q:close)\n\n#{lines.join("\n")}"
+          @editor.open_scratch_buffer("[LSP Picker]", content)
         end
       end
     end

data/lib/mui/lsp/handlers/formatting.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/formatting responses
+      class Formatting < Base
+        protected
+
+        def handle_result(result)
+          return handle_empty unless result.is_a?(Array) && !result.empty?
+
+          apply_text_edits(result)
+        end
+
+        def handle_empty
+          @editor.message = "No formatting changes"
+        end
+
+        private
+
+        def apply_text_edits(edits)
+          buffer = @editor.buffer
+          return @editor.message = "No buffer" unless buffer
+
+          # Sort edits in reverse order (bottom to top) to avoid position shifts
+          sorted_edits = edits.sort_by do |edit|
+            range = edit["range"]
+            start_line = range["start"]["line"]
+            start_char = range["start"]["character"]
+            [-start_line, -start_char]
+          end
+
+          # Apply each edit
+          changes_count = 0
+          sorted_edits.each do |edit|
+            apply_single_edit(buffer, edit)
+            changes_count += 1
+          end
+
+          @editor.message = "Formatted (#{changes_count} change#{"s" unless changes_count == 1})"
+        end
+
+        def apply_single_edit(buffer, edit)
+          range = edit["range"]
+          new_text = edit["newText"]
+
+          start_line = range["start"]["line"]
+          start_char = range["start"]["character"]
+          end_line = range["end"]["line"]
+          end_char = range["end"]["character"]
+
+          # Get current lines
+          lines = buffer.lines
+
+          # Build new content
+          # Get text before the edit range
+          before_text = if start_line < lines.length
+                          line = lines[start_line] || ""
+                          line[0, start_char] || ""
+                        else
+                          ""
+                        end
+
+          # Get text after the edit range
+          after_text = if end_line < lines.length
+                         line = lines[end_line] || ""
+                         line[end_char..] || ""
+                       else
+                         ""
+                       end
+
+          # Split new_text into lines
+          new_lines = new_text.split("\n", -1)
+
+          new_lines = [""] if new_lines.empty?
+
+          # Combine before_text with first new line
+          new_lines[0] = before_text + new_lines[0]
+
+          # Combine last new line with after_text
+          new_lines[-1] = new_lines[-1] + after_text
+
+          # Replace lines in buffer
+          # Delete old lines
+          delete_count = end_line - start_line + 1
+          delete_count.times do
+            buffer.delete_line(start_line) if start_line < buffer.lines.length
+          end
+
+          # Insert new lines
+          new_lines.each_with_index do |line, idx|
+            buffer.insert_line(start_line + idx, line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers/references.rb

@@ -11,7 +11,12 @@ module Mui
           return handle_empty unless result.is_a?(Array) && !result.empty?
 
           locations = result.map { |loc| Protocol::Location.from_hash(loc) }
-          show_references(locations)
+
+          if locations.length == 1
+            jump_to_location(locations.first)
+          else
+            show_location_list(locations)
+          end
         end
 
         def handle_empty
@@ -20,44 +25,52 @@ module Mui
 
         private
 
-        def show_references(locations)
-          count = locations.length
-
-          # Build message with first few references
-          lines = ["Found #{count} reference#{"s" unless count == 1}"]
-
-          # Group by file for display
-          by_file = locations.group_by(&:file_path)
-
-          # Display first few references
-          displayed = 0
-          max_display = 3
-
-          by_file.each do |file_path, file_locations|
-            break if displayed >= max_display
+        def jump_to_location(location)
+          file_path = location.file_path
+          unless file_path
+            @editor.message = "Cannot open: #{location.uri}"
+            return
+          end
 
-            file_locations.each do |loc|
-              break if displayed >= max_display
+          line = location.range.start.line
+          character = location.range.start.character
 
-              line = loc.range.start.line + 1
-              lines << "  #{file_path || loc.uri}:#{line}"
-              displayed += 1
-            end
+          # Open the file in current window
+          current_buffer = @editor.buffer
+          if current_buffer.file_path != file_path
+            new_buffer = Mui::Buffer.new
+            new_buffer.load(file_path)
+            @editor.window.buffer = new_buffer
           end
 
-          lines << "  ... and #{count - max_display} more" if count > max_display
+          # Jump to position
+          window = @editor.window
+          return unless window
 
-          @editor.message = lines.first
+          window.cursor_row = line
+          window.cursor_col = character
+          window.ensure_cursor_visible
 
-          # TODO: Integrate with quickfix list when available
-          # Store references for navigation
-          store_references(locations)
+          @editor.message = "#{File.basename(file_path)}:#{line + 1}"
         end
 
-        def store_references(locations)
-          # Store references for potential :cnext/:cprev navigation
-          # This could be integrated with Mui's quickfix system if available
-          @editor.instance_variable_set(:@lsp_references, locations)
+        def show_location_list(locations)
+          # Store locations for picker navigation
+          @editor.instance_variable_set(:@lsp_picker_locations, locations)
+          @editor.instance_variable_set(:@lsp_picker_type, :references)
+
+          # Build picker content
+          lines = []
+          locations.each_with_index do |loc, idx|
+            file_path = loc.file_path || loc.uri
+            display_path = File.basename(file_path.to_s)
+            line_num = loc.range.start.line + 1
+            lines << "#{idx + 1}. #{display_path}:#{line_num}"
+          end
+
+          # Open scratch buffer for picker
+          content = "References (#{locations.length} found) (\\Enter:open, Ctrl+t:tab, \\q:close)\n\n#{lines.join("\n")}"
+          @editor.open_scratch_buffer("[LSP Picker]", content)
         end
       end
     end

data/lib/mui/lsp/handlers/type_definition.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Mui
+  module Lsp
+    module Handlers
+      # Handler for textDocument/typeDefinition responses
+      class TypeDefinition < Base
+        protected
+
+        def handle_result(result)
+          locations = normalize_locations(result)
+          return handle_empty if locations.empty?
+
+          if locations.length == 1
+            jump_to_location(locations.first)
+          else
+            show_location_list(locations)
+          end
+        end
+
+        def handle_empty
+          @editor.message = "No type definition found"
+        end
+
+        private
+
+        def normalize_locations(result)
+          case result
+          when Array
+            result.map { |loc| parse_location(loc) }.compact
+          when Hash
+            location = parse_location(result)
+            location ? [location] : []
+          else
+            []
+          end
+        end
+
+        def parse_location(data)
+          return nil unless data
+
+          # Handle both Location and LocationLink
+          if data["targetUri"]
+            # LocationLink
+            Protocol::Location.new(
+              uri: data["targetUri"],
+              range: data["targetSelectionRange"] || data["targetRange"]
+            )
+          elsif data["uri"]
+            # Location
+            Protocol::Location.from_hash(data)
+          end
+        end
+
+        def jump_to_location(location)
+          file_path = location.file_path
+          unless file_path
+            @editor.message = "Cannot open: #{location.uri}"
+            return
+          end
+
+          line = location.range.start.line
+          character = location.range.start.character
+
+          # Open the file in current window
+          current_buffer = @editor.buffer
+          if current_buffer.file_path != file_path
+            # Need to open a different file
+            new_buffer = Mui::Buffer.new
+            new_buffer.load(file_path)
+            @editor.window.buffer = new_buffer
+          end
+
+          # Jump to position
+          window = @editor.window
+          return unless window
+
+          window.cursor_row = line
+          window.cursor_col = character
+          window.ensure_cursor_visible
+
+          @editor.message = "#{File.basename(file_path)}:#{line + 1}"
+        end
+
+        def show_location_list(locations)
+          # Store locations for picker navigation
+          @editor.instance_variable_set(:@lsp_picker_locations, locations)
+          @editor.instance_variable_set(:@lsp_picker_type, :type_definition)
+
+          # Build picker content
+          lines = []
+          locations.each_with_index do |loc, idx|
+            file_path = loc.file_path || loc.uri
+            display_path = File.basename(file_path.to_s)
+            line_num = loc.range.start.line + 1
+            lines << "#{idx + 1}. #{display_path}:#{line_num}"
+          end
+
+          # Open scratch buffer for picker
+          content = "Type Definitions (\\Enter:open, Ctrl+t:tab, \\q:close)\n\n#{lines.join("\n")}"
+          @editor.open_scratch_buffer("[LSP Picker]", content)
+        end
+      end
+    end
+  end
+end

data/lib/mui/lsp/handlers.rb

@@ -3,6 +3,8 @@
 require_relative "handlers/base"
 require_relative "handlers/hover"
 require_relative "handlers/definition"
+require_relative "handlers/type_definition"
 require_relative "handlers/references"
 require_relative "handlers/diagnostics"
 require_relative "handlers/completion"
+require_relative "handlers/formatting"

data/lib/mui/lsp/manager.rb

@@ -86,6 +86,20 @@ module Mui
         nil
       end
 
+      def client_for_capability(file_path, capability)
+        @mutex.synchronize do
+          @server_configs.each do |name, config|
+            next unless config.handles_file?(file_path)
+            next unless @clients[name]&.running?
+
+            # Check if server supports the capability
+            capabilities = @clients[name].server_capabilities
+            return @clients[name] if capabilities[capability]
+          end
+        end
+        nil
+      end
+
       def text_sync_for(file_path)
         @mutex.synchronize do
           @server_configs.each do |name, config|
@@ -215,21 +229,106 @@ module Mui
       end
 
       def definition(file_path:, line:, character:)
-        client = client_for(file_path)
-        unless client
+        text_syncs = text_syncs_for(file_path)
+        if text_syncs.empty?
           @editor.message = server_unavailable_message(file_path)
           return
         end
 
         uri = TextDocumentSync.path_to_uri(file_path)
-        handler = Handlers::Definition.new(editor: @editor, client: client)
+        handler = Handlers::Definition.new(editor: @editor, client: text_syncs.first.client)
+
+        # Collect results from all clients
+        results_mutex = Mutex.new
+        pending_count = text_syncs.size
+        all_results = []
+
+        text_syncs.each do |text_sync|
+          text_sync.client.definition(uri: uri, line: line, character: character) do |result, _error|
+            results_mutex.synchronize do
+              all_results << result if result
+              pending_count -= 1
+
+              if pending_count.zero?
+                merged = merge_locations(all_results)
+                handler.handle(merged, nil)
+              end
+            end
+          end
+        end
+      end
 
-        client.definition(uri: uri, line: line, character: character) do |result, error|
-          handler.handle(result, error)
+      def type_definition(file_path:, line:, character:)
+        # Only send to servers that support typeDefinitionProvider
+        text_syncs = text_syncs_for(file_path).select do |ts|
+          ts.client.server_capabilities["typeDefinitionProvider"]
+        end
+
+        if text_syncs.empty?
+          # Fallback message: check if any server is running but doesn't support typeDefinition
+          any_text_sync = text_syncs_for(file_path).first
+          @editor.message = if any_text_sync
+                              "LSP: no server supports typeDefinition for this file"
+                            else
+                              server_unavailable_message(file_path)
+                            end
+          return
+        end
+
+        uri = TextDocumentSync.path_to_uri(file_path)
+        handler = Handlers::TypeDefinition.new(editor: @editor, client: text_syncs.first.client)
+
+        # Collect results from all clients
+        results_mutex = Mutex.new
+        pending_count = text_syncs.size
+        all_results = []
+
+        text_syncs.each do |text_sync|
+          text_sync.client.type_definition(uri: uri, line: line, character: character) do |result, _error|
+            results_mutex.synchronize do
+              all_results << result if result
+              pending_count -= 1
+
+              if pending_count.zero?
+                merged = merge_locations(all_results)
+                handler.handle(merged, nil)
+              end
+            end
+          end
         end
       end
 
       def references(file_path:, line:, character:)
+        text_syncs = text_syncs_for(file_path)
+        if text_syncs.empty?
+          @editor.message = server_unavailable_message(file_path)
+          return
+        end
+
+        uri = TextDocumentSync.path_to_uri(file_path)
+        handler = Handlers::References.new(editor: @editor, client: text_syncs.first.client)
+
+        # Collect results from all clients
+        results_mutex = Mutex.new
+        pending_count = text_syncs.size
+        all_results = []
+
+        text_syncs.each do |text_sync|
+          text_sync.client.references(uri: uri, line: line, character: character) do |result, _error|
+            results_mutex.synchronize do
+              all_results << result if result
+              pending_count -= 1
+
+              if pending_count.zero?
+                merged = merge_locations(all_results)
+                handler.handle(merged, nil)
+              end
+            end
+          end
+        end
+      end
+
+      def completion(file_path:, line:, character:)
         client = client_for(file_path)
         unless client
           @editor.message = server_unavailable_message(file_path)
@@ -237,14 +336,14 @@ module Mui
         end
 
         uri = TextDocumentSync.path_to_uri(file_path)
-        handler = Handlers::References.new(editor: @editor, client: client)
+        handler = Handlers::Completion.new(editor: @editor, client: client)
 
-        client.references(uri: uri, line: line, character: character) do |result, error|
+        client.completion(uri: uri, line: line, character: character) do |result, error|
           handler.handle(result, error)
         end
       end
 
-      def completion(file_path:, line:, character:)
+      def format(file_path:, tab_size: 2, insert_spaces: true)
         client = client_for(file_path)
         unless client
           @editor.message = server_unavailable_message(file_path)
@@ -252,13 +351,48 @@ module Mui
         end
 
         uri = TextDocumentSync.path_to_uri(file_path)
-        handler = Handlers::Completion.new(editor: @editor, client: client)
+        handler = Handlers::Formatting.new(editor: @editor, client: client)
 
-        client.completion(uri: uri, line: line, character: character) do |result, error|
+        client.formatting(uri: uri, tab_size: tab_size, insert_spaces: insert_spaces) do |result, error|
           handler.handle(result, error)
         end
       end
 
+      def jump_to_type_file(file_path:, line: nil, character: nil)
+        # For Ruby/RBS files, use custom toggle behavior
+        if file_path&.end_with?(".rb", ".rbs")
+          jump_to_ruby_type_file(file_path)
+        else
+          # For other languages, use LSP typeDefinition
+          type_definition(file_path: file_path, line: line, character: character)
+        end
+      end
+
+      private
+
+      def jump_to_ruby_type_file(file_path)
+        target_path = if file_path.end_with?(".rb")
+                        find_rbs_file(file_path)
+                      else
+                        find_ruby_file(file_path)
+                      end
+
+        unless target_path
+          ext = File.extname(file_path)
+          target_ext = ext == ".rb" ? ".rbs" : ".rb"
+          @editor.message = "No #{target_ext} file found for #{File.basename(file_path)}"
+          return
+        end
+
+        # Open the target file
+        new_buffer = Mui::Buffer.new
+        new_buffer.load(target_path)
+        @editor.window.buffer = new_buffer
+        @editor.message = "Opened #{File.basename(target_path)}"
+      end
+
+      public
+
       def running_servers
         @mutex.synchronize do
           @clients.select { |_, client| client.running? }.keys
@@ -293,6 +427,80 @@ module Mui
 
       private
 
+      def merge_locations(results)
+        # Flatten all results into a single array
+        merged = results.flat_map do |result|
+          case result
+          when Array then result
+          when Hash then [result]
+          else []
+          end
+        end
+
+        # Remove duplicates based on uri and range
+        merged.uniq do |loc|
+          uri = loc["uri"] || loc["targetUri"]
+          range = loc["range"] || loc["targetSelectionRange"]
+          [uri, range]
+        end
+      end
+
+      def find_rbs_file(ruby_file_path)
+        # Find project root
+        project_root = find_project_root(ruby_file_path)
+
+        # Get relative path from project root
+        abs_path = File.expand_path(ruby_file_path)
+        rel_path = abs_path.sub("#{project_root}/", "")
+
+        # Try different RBS path patterns
+        candidates = []
+
+        # Pattern 1: sig/relative_path.rbs (e.g., lib/mui/config.rb -> sig/lib/mui/config.rbs)
+        candidates << File.join(project_root, "sig", rel_path.sub(/\.rb$/, ".rbs"))
+
+        # Pattern 2: sig/without_lib.rbs (e.g., lib/mui/config.rb -> sig/mui/config.rbs)
+        if rel_path.start_with?("lib/")
+          candidates << File.join(project_root, "sig", rel_path.sub(%r{^lib/}, "").sub(/\.rb$/, ".rbs"))
+        end
+
+        # Pattern 3: sig/basename.rbs (e.g., lib/mui/config.rb -> sig/config.rbs)
+        candidates << File.join(project_root, "sig", "#{File.basename(ruby_file_path, ".rb")}.rbs")
+
+        # Return first existing file
+        candidates.find { |path| File.exist?(path) }
+      end
+
+      def find_ruby_file(rbs_file_path)
+        # Find project root
+        project_root = find_project_root(rbs_file_path)
+
+        # Get relative path from project root
+        abs_path = File.expand_path(rbs_file_path)
+        rel_path = abs_path.sub("#{project_root}/", "")
+
+        # Remove sig/ prefix if present
+        rel_path = rel_path.sub(%r{^sig/}, "")
+
+        # Try different Ruby path patterns
+        candidates = []
+
+        # Pattern 1: lib/relative_path.rb (e.g., sig/mui/config.rbs -> lib/mui/config.rb)
+        candidates << File.join(project_root, "lib", rel_path.sub(/\.rbs$/, ".rb"))
+
+        # Pattern 2: relative_path.rb without lib (e.g., sig/lib/mui/config.rbs -> lib/mui/config.rb)
+        candidates << File.join(project_root, rel_path.sub(/\.rbs$/, ".rb")) if rel_path.start_with?("lib/")
+
+        # Pattern 3: Search in lib directory for basename
+        basename = File.basename(rbs_file_path, ".rbs")
+        Dir.glob(File.join(project_root, "lib", "**", "#{basename}.rb")).each do |path|
+          candidates << path
+        end
+
+        # Return first existing file
+        candidates.find { |path| File.exist?(path) }
+      end
+
       def send_pending_documents(server_name)
         text_sync = @mutex.synchronize { @text_syncs[server_name] }
         config = @mutex.synchronize { @server_configs[server_name] }

data/lib/mui/lsp/plugin.rb

@@ -6,7 +6,7 @@ module Mui
   module Lsp
     # Main plugin class for mui-lsp
     # Registers commands and keymaps for LSP integration
-    class Plugin < Mui::Plugin
+    class Plugin < Mui::Plugin # rubocop:disable Metrics/ClassLength
       name "lsp"
 
       def setup
@@ -44,6 +44,11 @@ module Mui
           handle_lsp_definition(ctx)
         end
 
+        # :LspTypeDefinition - Go to type definition
+        command(:LspTypeDefinition) do |ctx, _args|
+          handle_lsp_type_definition(ctx)
+        end
+
         # :LspReferences - Show references
         command(:LspReferences) do |ctx, _args|
           handle_lsp_references(ctx)
@@ -78,6 +83,11 @@ module Mui
         command(:LspOpen) do |ctx, _args|
           handle_lsp_open(ctx)
         end
+
+        # :LspFormat - Format current file
+        command(:LspFormat) do |ctx, _args|
+          handle_lsp_format(ctx)
+        end
       end
 
       def register_keymaps
@@ -87,75 +97,46 @@ module Mui
           true
         end
 
-        # Leader key (\) - start pending mode
-        keymap(:normal, "\\") do |_ctx|
-          @leader_pending = true
+        # <Space>df - Go to definition
+        keymap(:normal, "<Space>df") do |ctx|
+          handle_lsp_definition(ctx)
           true
         end
 
-        # \d - Go to definition
-        keymap(:normal, "d") do |ctx|
-          if @leader_pending
-            @leader_pending = false
-            handle_lsp_definition(ctx)
-            true
-          else
-            false # Let default 'd' handle it
-          end
+        # <Space>tf - Go to type definition (toggle between .rb and .rbs)
+        keymap(:normal, "<Space>tf") do |ctx|
+          handle_lsp_jump_to_type_file(ctx)
+          true
         end
 
-        # \r - Go to references
-        keymap(:normal, "r") do |ctx|
-          if @leader_pending
-            @leader_pending = false
-            handle_lsp_references(ctx)
-            true
-          else
-            false # Let default 'r' handle it
-          end
+        # <Space>rf - Find references
+        keymap(:normal, "<Space>rf") do |ctx|
+          handle_lsp_references(ctx)
+          true
         end
 
-        # \h - Show hover (alternative to K)
-        keymap(:normal, "h") do |ctx|
-          if @leader_pending
-            @leader_pending = false
-            handle_lsp_hover(ctx)
-            true
-          else
-            false # Let default 'h' handle it
-          end
+        # <Space>hf - Show hover (alternative to K)
+        keymap(:normal, "<Space>hf") do |ctx|
+          handle_lsp_hover(ctx)
+          true
         end
 
-        # \c - Show completion
-        keymap(:normal, "c") do |ctx|
-          if @leader_pending
-            @leader_pending = false
-            handle_lsp_completion(ctx)
-            true
-          else
-            false # Let default 'c' handle it
-          end
+        # <Space>cf - Show completion
+        keymap(:normal, "<Space>cf") do |ctx|
+          handle_lsp_completion(ctx)
+          true
         end
 
-        # \e - Show diagnostic at cursor
-        keymap(:normal, "e") do |ctx|
-          if @leader_pending
-            @leader_pending = false
-            handle_lsp_diagnostic_show(ctx)
-            true
-          else
-            false # Let default 'e' handle it
-          end
+        # <Space>ef - Show diagnostic at cursor
+        keymap(:normal, "<Space>ef") do |ctx|
+          handle_lsp_diagnostic_show(ctx)
+          true
         end
 
-        # Cancel leader pending on any other key (via Escape)
-        keymap(:normal, "\e") do |_ctx|
-          if @leader_pending
-            @leader_pending = false
-            true
-          else
-            false
-          end
+        # <Space>ff - Format current file
+        keymap(:normal, "<Space>ff") do |ctx|
+          handle_lsp_format(ctx)
+          true
         end
 
         # Insert mode: Ctrl+Space - Trigger LSP completion
@@ -163,6 +144,38 @@ module Mui
           handle_lsp_completion(ctx)
           true
         end
+
+        # Picker navigation: Leader+Enter - open selected
+        keymap(:normal, "<Leader><CR>") do |ctx|
+          next unless picker_active?(ctx.editor)
+
+          handle_picker_select(ctx, new_tab: false)
+          true
+        end
+
+        # Picker navigation: Ctrl+t - open in new tab
+        keymap(:normal, "<C-t>") do |ctx|
+          next unless picker_active?(ctx.editor)
+
+          handle_picker_select(ctx, new_tab: true)
+          true
+        end
+
+        # Picker navigation: Leader+q - close picker
+        keymap(:normal, "<Leader>q") do |ctx|
+          next unless picker_active?(ctx.editor)
+
+          close_picker(ctx.editor)
+          true
+        end
+
+        # Picker navigation: Leader+Esc - close picker
+        keymap(:normal, "<Leader><Esc>") do |ctx|
+          next unless picker_active?(ctx.editor)
+
+          close_picker(ctx.editor)
+          true
+        end
       end
 
       def register_autocmds
@@ -283,6 +296,18 @@ module Mui
         get_manager(ctx.editor).definition(file_path: file_path, line: line, character: character)
       end
 
+      def handle_lsp_jump_to_type_file(ctx)
+        file_path = ctx.buffer.file_path
+        unless file_path
+          ctx.set_message("LSP: no file path")
+          return
+        end
+
+        line = ctx.window.cursor_row
+        character = ctx.window.cursor_col
+        get_manager(ctx.editor).jump_to_type_file(file_path: file_path, line: line, character: character)
+      end
+
       def handle_lsp_references(ctx)
         file_path = ctx.buffer.file_path
         unless file_path
@@ -456,6 +481,22 @@ module Mui
         ctx.set_message("LSP: opened #{File.basename(file_path)}")
       end
 
+      def handle_lsp_format(ctx)
+        file_path = ctx.buffer.file_path
+        unless file_path
+          ctx.set_message("LSP: no file path")
+          return
+        end
+
+        mgr = get_manager(ctx.editor)
+        text = ctx.buffer.lines.join("\n")
+
+        # Sync document before formatting
+        mgr.sync_now(file_path: file_path, text: text)
+
+        mgr.format(file_path: file_path)
+      end
+
       public
 
       def get_manager(editor)
@@ -478,14 +519,80 @@ module Mui
                    ServerConfig.rubocop_lsp(auto_start: true)
                  when :kanayago
                    ServerConfig.kanayago(auto_start: true)
+                 when :steep
+                   ServerConfig.steep(auto_start: true)
                  else
-                   raise ArgumentError, "Unknown server: #{name}. Use :solargraph, :ruby_lsp, :rubocop, or :kanayago"
+                   raise ArgumentError, "Unknown server: #{name}. Use :solargraph, :ruby_lsp, :rubocop, :kanayago, or :steep"
                  end
         register_server(config)
       end
 
       private
 
+      # Picker helpers
+
+      def picker_active?(editor)
+        # Check if current buffer is the picker buffer
+        editor.buffer&.file_path == "[LSP Picker]"
+      end
+
+      def handle_picker_select(ctx, new_tab:)
+        locations = ctx.editor.instance_variable_get(:@lsp_picker_locations)
+        return unless locations
+
+        # Get selected index from cursor position (line 3+ are the items, 0-indexed)
+        cursor_row = ctx.window.cursor_row
+        index = cursor_row - 2 # Skip header lines
+        return if index.negative? || index >= locations.length
+
+        location = locations[index]
+        close_picker(ctx.editor)
+        jump_to_location(ctx, location, new_tab: new_tab)
+      end
+
+      def close_picker(editor)
+        editor.instance_variable_set(:@lsp_picker_locations, nil)
+        editor.instance_variable_set(:@lsp_picker_type, nil)
+        # Close the picker window
+        editor.window_manager.close_current_window
+      end
+
+      def jump_to_location(ctx, location, new_tab:)
+        file_path = location.file_path
+        unless file_path
+          ctx.set_message("Cannot open: #{location.uri}")
+          return
+        end
+
+        line = location.range.start.line
+        character = location.range.start.character
+
+        if new_tab
+          # Open in new tab (same as :tabnew command)
+          tab_manager = ctx.editor.tab_manager
+          new_tab_obj = tab_manager.add
+          new_buffer = Mui::Buffer.new
+          new_buffer.load(file_path)
+          new_buffer.undo_manager = Mui::UndoManager.new
+          new_tab_obj.window_manager.add_window(new_buffer)
+        else
+          # Open in current window
+          current_buffer = ctx.buffer
+          if current_buffer.file_path != file_path
+            new_buffer = Mui::Buffer.new
+            new_buffer.load(file_path)
+            ctx.editor.window.buffer = new_buffer
+          end
+        end
+
+        window = ctx.editor.window
+        window.cursor_row = line
+        window.cursor_col = character
+        window.ensure_cursor_visible
+
+        ctx.set_message("#{File.basename(file_path)}:#{line + 1}")
+      end
+
       def create_manager(editor)
         mgr = Manager.new(editor: editor)
         # Register configured servers
@@ -526,8 +633,13 @@ module Mui
                    ServerConfig.rubocop_lsp(auto_start: true)
                  when :kanayago
                    ServerConfig.kanayago(auto_start: true)
+                 when :typeprof
+                   ServerConfig.typeprof(auto_start: true)
+                 when :steep
+                   ServerConfig.steep(auto_start: true)
                  else
-                   raise ArgumentError, "Unknown server: #{name}. Use :solargraph, :ruby_lsp, :rubocop, or :kanayago"
+                   raise ArgumentError,
+                         "Unknown server: #{name}. Use :solargraph, :ruby_lsp, :rubocop, :kanayago, :typeprof, or :steep"
                  end
         @server_configs << config
       end

data/lib/mui/lsp/server_config.rb

@@ -26,6 +26,8 @@ module Mui
         case ext
         when ".rb", ".rake", ".gemspec", ".ru"
           "ruby"
+        when ".rbs"
+          "rbs"
         when ".js"
           "javascript"
         when ".ts"
@@ -99,6 +101,26 @@ module Mui
           )
         end
 
+        def typeprof(auto_start: false)
+          new(
+            name: "typeprof",
+            command: "typeprof --lsp --stdio",
+            language_ids: ["ruby"],
+            file_patterns: ["**/*.rb", "**/*.rake", "**/Gemfile", "**/Rakefile", "**/*.gemspec"],
+            auto_start: auto_start
+          )
+        end
+
+        def steep(auto_start: false)
+          new(
+            name: "steep",
+            command: "steep langserver",
+            language_ids: %w[ruby rbs],
+            file_patterns: ["**/*.rb", "**/*.rbs", "**/*.rake", "**/Gemfile", "**/Rakefile", "**/*.gemspec"],
+            auto_start: auto_start
+          )
+        end
+
         def custom(name:, command:, language_ids:, file_patterns:, auto_start: true, sync_on_change: true)
           new(
             name: name,

data/lib/mui/lsp/text_document_sync.rb

@@ -8,6 +8,8 @@ module Mui
     class TextDocumentSync
       DEFAULT_DEBOUNCE_MS = 300
 
+      attr_reader :client
+
       def initialize(client:, server_config:, debounce_ms: DEFAULT_DEBOUNCE_MS)
         @client = client
         @server_config = server_config

data/lib/mui/lsp/version.rb

@@ -2,6 +2,6 @@
 
 module Mui
   module Lsp
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mui-lsp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - S-H-GAMELINKS
@@ -43,8 +43,10 @@ files:
 - lib/mui/lsp/handlers/completion.rb
 - lib/mui/lsp/handlers/definition.rb
 - lib/mui/lsp/handlers/diagnostics.rb
+- lib/mui/lsp/handlers/formatting.rb
 - lib/mui/lsp/handlers/hover.rb
 - lib/mui/lsp/handlers/references.rb
+- lib/mui/lsp/handlers/type_definition.rb
 - lib/mui/lsp/highlighters/diagnostic_highlighter.rb
 - lib/mui/lsp/json_rpc_io.rb
 - lib/mui/lsp/manager.rb
@@ -83,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.2
 specification_version: 4
 summary: LSP (Language Server Protocol) plugin for Mui editor
 test_files: []