fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/lsp/client.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+module Gsd
+  module LSP
+    # Client - Manages communication with LSP server
+    class Client
+      attr_reader :state, :server_info, :capabilities
+      attr_accessor :on_diagnostics, :on_log_message
+
+      def initialize(command, args = [])
+        @command = command
+        @args = args
+        @state = :stopped
+        @request_id = 0
+        @pending_requests = {}
+        @server_info = nil
+        @capabilities = {}
+        @buffer = ''
+        @mutex = Mutex.new
+        @on_diagnostics = nil
+        @on_log_message = nil
+      end
+
+      # Start the LSP server
+      def start
+        return false if @state != :stopped
+
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(*[@command, *@args])
+        @state = :starting
+
+        # Start reader thread
+        @reader_thread = Thread.new { reader_loop }
+
+        # Initialize
+        initialize_server
+
+        true
+      rescue StandardError => e
+        @state = :stopped
+        warn "[LSP] Failed to start server: #{e.message}"
+        false
+      end
+
+      # Stop the LSP server
+      def stop
+        return false if @state == :stopped
+
+        begin
+          send_request(Protocol::Methods::SHUTDOWN)
+          send_notification(Protocol::Methods::EXIT)
+        rescue StandardError => e
+          warn "[LSP] Error during shutdown: #{e.message}"
+        end
+
+        @state = :stopped
+
+        # Kill threads
+        @reader_thread&.kill
+        @wait_thr&.kill
+
+        # Close streams
+        @stdin&.close
+        @stdout&.close
+        @stderr&.close
+
+        true
+      end
+
+      # Check if running
+      def running?
+        @state == :running
+      end
+
+      # Send request and wait for response
+      def request(method, params = nil, timeout: 30)
+        return nil unless running?
+
+        id = next_request_id
+        message = Protocol.build_request(method, params, id)
+
+        send_raw(message)
+
+        # Wait for response
+        response = wait_for_response(id, timeout)
+
+        if response && response['error']
+          warn "[LSP] Request #{id} failed: #{response['error']['message']}"
+          nil
+        else
+          response&.[]('result')
+        end
+      end
+
+      # Send notification (no response expected)
+      def notify(method, params = nil)
+        return false unless running?
+
+        message = Protocol.build_notification(method, params)
+        send_raw(message)
+        true
+      end
+
+      # Open a document
+      def open_document(uri, language_id, text, version: 1)
+        notify(Protocol::Methods::TEXT_DOCUMENT_DID_OPEN, {
+          textDocument: {
+            uri: uri,
+            languageId: language_id,
+            version: version,
+            text: text
+          }
+        })
+      end
+
+      # Update document
+      def change_document(uri, changes, version:)
+        notify(Protocol::Methods::TEXT_DOCUMENT_DID_CHANGE, {
+          textDocument: {
+            uri: uri,
+            version: version
+          },
+          contentChanges: changes
+        })
+      end
+
+      # Close document
+      def close_document(uri)
+        notify(Protocol::Methods::TEXT_DOCUMENT_DID_CLOSE, {
+          textDocument: { uri: uri }
+        })
+      end
+
+      # Get completions
+      def completion(uri, line, character)
+        request(Protocol::Methods::TEXT_DOCUMENT_COMPLETION, {
+          textDocument: { uri: uri },
+          position: { line: line, character: character }
+        })
+      end
+
+      # Get hover info
+      def hover(uri, line, character)
+        request(Protocol::Methods::TEXT_DOCUMENT_HOVER, {
+          textDocument: { uri: uri },
+          position: { line: line, character: character }
+        })
+      end
+
+      # Get definition
+      def definition(uri, line, character)
+        request(Protocol::Methods::TEXT_DOCUMENT_DEFINITION, {
+          textDocument: { uri: uri },
+          position: { line: line, character: character }
+        })
+      end
+
+      # Get references
+      def references(uri, line, character, include_declaration: false)
+        request(Protocol::Methods::TEXT_DOCUMENT_REFERENCES, {
+          textDocument: { uri: uri },
+          position: { line: line, character: character },
+          context: { includeDeclaration: include_declaration }
+        })
+      end
+
+      # Get document symbols
+      def document_symbol(uri)
+        request(Protocol::Methods::TEXT_DOCUMENT_DOCUMENT_SYMBOL, {
+          textDocument: { uri: uri }
+        })
+      end
+
+      # Get workspace symbols
+      def workspace_symbol(query)
+        request(Protocol::Methods::WORKSPACE_SYMBOL, {
+          query: query
+        })
+      end
+
+      # Format document
+      def formatting(uri)
+        request(Protocol::Methods::TEXT_DOCUMENT_FORMATTING, {
+          textDocument: { uri: uri },
+          options: { tabSize: 2, insertSpaces: true }
+        })
+      end
+
+      # Rename symbol
+      def rename(uri, line, character, new_name)
+        request(Protocol::Methods::TEXT_DOCUMENT_RENAME, {
+          textDocument: { uri: uri },
+          position: { line: line, character: character },
+          newName: new_name
+        })
+      end
+
+      private
+
+      def initialize_server
+        # Send initialize request
+        result = request(Protocol::Methods::INITIALIZE, {
+          processId: Process.pid,
+          rootUri: "file://#{Dir.pwd}",
+          capabilities: client_capabilities
+        }, timeout: 10)
+
+        if result
+          @server_info = result['serverInfo']
+          @capabilities = result['capabilities'] || {}
+          @state = :running
+
+          # Send initialized notification
+          notify(Protocol::Methods::INITIALIZED, {})
+        else
+          @state = :error
+        end
+      end
+
+      def client_capabilities
+        {
+          textDocument: {
+            synchronization: {
+              dynamicRegistration: false,
+              willSave: false,
+              willSaveWaitUntil: false,
+              didSave: false
+            },
+            completion: {
+              dynamicRegistration: false,
+              completionItem: {
+                snippetSupport: false,
+                commitCharactersSupport: false,
+                documentationFormat: ['plaintext', 'markdown'],
+                deprecatedSupport: false,
+                preselectSupport: false
+              }
+            },
+            hover: {
+              dynamicRegistration: false,
+              contentFormat: ['plaintext', 'markdown']
+            },
+            definition: {
+              dynamicRegistration: false,
+              linkSupport: false
+            },
+            documentSymbol: {
+              dynamicRegistration: false,
+              hierarchicalDocumentSymbolSupport: false,
+              symbolKind: { valueSet: (1..26).to_a }
+            },
+            formatting: {
+              dynamicRegistration: false
+            },
+            rename: {
+              dynamicRegistration: false,
+              prepareSupport: false
+            }
+          },
+          workspace: {
+            applyEdit: false,
+            workspaceEdit: {
+              documentChanges: false
+            },
+            didChangeConfiguration: {
+              dynamicRegistration: false
+            },
+            symbol: {
+              dynamicRegistration: false,
+              symbolKind: { valueSet: (1..26).to_a }
+            },
+            executeCommand: {
+              dynamicRegistration: false
+            }
+          }
+        }
+      end
+
+      def next_request_id
+        @mutex.synchronize do
+          @request_id += 1
+        end
+      end
+
+      def send_raw(message)
+        data = Protocol.format_message(message)
+        @mutex.synchronize do
+          @stdin.write(data)
+          @stdin.flush
+        end
+      rescue StandardError => e
+        warn "[LSP] Failed to send message: #{e.message}"
+      end
+
+      def reader_loop
+        loop do
+          begin
+            data = @stdout.readpartial(8192)
+            @buffer << data
+
+            # Parse all complete messages
+            loop do
+              result = Protocol.parse_message(@buffer)
+              break unless result
+
+              @buffer = result[:remaining] || ''
+              handle_message(result[:message])
+            end
+          rescue EOFError, IOError
+            break
+          rescue StandardError => e
+            warn "[LSP] Reader error: #{e.message}"
+          end
+        end
+      end
+
+      def handle_message(message)
+        if message['id']
+          # Response to a request
+          handle_response(message)
+        else
+          # Server notification
+          handle_notification(message)
+        end
+      end
+
+      def handle_response(message)
+        id = message['id']
+        @mutex.synchronize do
+          @pending_requests[id] = message
+        end
+      end
+
+      def handle_notification(message)
+        method = message['method']
+        params = message['params']
+
+        case method
+        when Protocol::Methods::TEXT_DOCUMENT_PUBLISH_DIAGNOSTICS
+          handle_diagnostics(params)
+        when 'window/logMessage'
+          handle_log_message(params)
+        when 'window/showMessage'
+          handle_show_message(params)
+        end
+      end
+
+      def wait_for_response(id, timeout)
+        deadline = Time.now + timeout
+
+        loop do
+          remaining = deadline - Time.now
+          return nil if remaining <= 0
+
+          response = nil
+          @mutex.synchronize do
+            response = @pending_requests.delete(id)
+          end
+
+          return response if response
+
+          sleep(0.01)
+        end
+      end
+
+      def handle_diagnostics(params)
+        return unless @on_diagnostics
+
+        uri = params['uri']
+        diagnostics = params['diagnostics']&.map do |d|
+          Protocol::Diagnostic.from_h(d)
+        end || []
+
+        @on_diagnostics.call(uri, diagnostics)
+      end
+
+      def handle_log_message(params)
+        return unless @on_log_message
+
+        type = params['type']
+        message = params['message']
+        @on_log_message.call(type, message)
+      end
+
+      def handle_show_message(params)
+        type = params['type']
+        message = params['message']
+        warn "[LSP Server] #{message}"
+      end
+    end
+  end
+end

data/lib/gsd/lsp/completion.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Gsd
+  module LSP
+    # Completion - Handles LSP autocompletion
+    class Completion
+      attr_reader :client, :cache, :cache_ttl
+
+      def initialize(client)
+        @client = client
+        @cache = {}
+        @cache_ttl = 5 # seconds
+        @mutex = Mutex.new
+      end
+
+      # Get completions at position
+      def get(uri, line, character)
+        return nil unless @client&.running?
+
+        cache_key = "#{uri}:#{line}:#{character}"
+
+        # Check cache
+        cached = check_cache(cache_key)
+        return cached if cached
+
+        # Request from server
+        result = @client.completion(uri, line, character)
+        return nil unless result
+
+        # Parse completions
+        items = parse_completion_result(result)
+
+        # Cache result
+        store_cache(cache_key, items)
+
+        items
+      end
+
+      # Get completion at cursor from text
+      def get_at_cursor(file_path, text, cursor_pos)
+        line, character = position_from_offset(text, cursor_pos)
+        uri = path_to_uri(file_path)
+
+        get(uri, line, character)
+      end
+
+      # Trigger character completion
+      def trigger_character?(char)
+        %w[. : > ].include?(char)
+      end
+
+      # Filter completions by prefix
+      def filter(items, prefix)
+        return items if prefix.empty?
+
+        prefix_lower = prefix.downcase
+        items.select do |item|
+          label = item[:label].downcase
+          label.start_with?(prefix_lower) || label.include?(prefix_lower)
+        end
+      end
+
+      # Sort completions by relevance
+      def sort(items, prefix)
+        prefix_lower = prefix.downcase
+
+        items.sort_by do |item|
+          label = item[:label].downcase
+
+          if label == prefix_lower
+            0
+          elsif label.start_with?(prefix_lower)
+            1
+          elsif label.include?(prefix_lower)
+            2
+          else
+            3
+          end
+        end
+      end
+
+      # Format completion for display
+      def format_item(item, width: 40)
+        label = item[:label]
+        kind = kind_to_symbol(item[:kind])
+        detail = item[:detail]
+
+        text = "#{kind} #{label}"
+        text += " - #{detail}" if detail && detail.length < width - text.length - 3
+
+        text[0...width]
+      end
+
+      # Format completion list for TUI
+      def format_list(items, selected_index: 0, width: 40, max_items: 10)
+        return [] if items.empty?
+
+        display_items = items.first(max_items)
+
+        display_items.map.with_index do |item, index|
+          prefix = index == selected_index ? '>' : ' '
+          formatted = format_item(item, width: width - 2)
+          "#{prefix} #{formatted}"
+        end
+      end
+
+      # Clear cache
+      def clear_cache
+        @mutex.synchronize do
+          @cache.clear
+        end
+      end
+
+      private
+
+      def parse_completion_result(result)
+        # Handle different response formats
+        items = if result.is_a?(Array)
+                  result
+                elsif result.is_a?(Hash)
+                  result['items'] || []
+                else
+                  []
+                end
+
+        items.map { |item| normalize_item(item) }
+      end
+
+      def normalize_item(item)
+        {
+          label: item['label'] || item[:label],
+          kind: item['kind'] || item[:kind],
+          detail: item['detail'] || item[:detail],
+          documentation: item['documentation'] || item[:documentation],
+          insertText: item['insertText'] || item['insertText'] || item['label'] || item[:label],
+          sortText: item['sortText'] || item['sortText'] || item['label'] || item[:label]
+        }
+      end
+
+      def check_cache(key)
+        @mutex.synchronize do
+          entry = @cache[key]
+          return nil unless entry
+
+          if Time.now - entry[:time] > @cache_ttl
+            @cache.delete(key)
+            nil
+          else
+            entry[:items]
+          end
+        end
+      end
+
+      def store_cache(key, items)
+        @mutex.synchronize do
+          @cache[key] = {
+            items: items,
+            time: Time.now
+          }
+
+          # Limit cache size
+          while @cache.size > 100
+            @cache.shift
+          end
+        end
+      end
+
+      def position_from_offset(text, offset)
+        line = 0
+        character = 0
+
+        text[0...offset].each_char do |char|
+          if char == "\n"
+            line += 1
+            character = 0
+          else
+            character += 1
+          end
+        end
+
+        [line, character]
+      end
+
+      def path_to_uri(path)
+        absolute = File.expand_path(path)
+        "file://#{absolute}"
+      end
+
+      def kind_to_symbol(kind)
+        symbols = {
+          1 => 'Ⓣ',   # Text
+          2 => 'Ⓜ',   # Method
+          3 => 'Ⓕ',   # Function
+          4 => 'Ⓒ',   # Constructor
+          5 => 'Ⓕ',   # Field
+          6 => 'Ⓥ',   # Variable
+          7 => 'Ⓒ',   # Class
+          8 => 'Ⓘ',   # Interface
+          9 => 'Ⓜ',   # Module
+          10 => 'Ⓟ',  # Property
+          11 => 'Ⓤ',  # Unit
+          12 => 'Ⓥ',  # Value
+          13 => 'Ⓔ',  # Enum
+          14 => 'Ⓚ',  # Keyword
+          15 => 'Ⓢ',  # Snippet
+          16 => 'Ⓒ',  # Color
+          17 => 'Ⓕ',  # File
+          18 => 'Ⓡ'   # Reference
+        }
+
+        symbols[kind] || '❓'
+      end
+    end
+
+    # CompletionTrigger - Detects when to trigger completion
+    class CompletionTrigger
+      attr_reader :trigger_chars, :commit_chars
+
+      def initialize
+        @trigger_chars = %w[. : > " ' /]
+        @commit_chars = %w[. ( ) , ;]
+      end
+
+      # Check if character should trigger completion
+      def should_trigger?(char, before_cursor)
+        return true if @trigger_chars.include?(char)
+
+        # Trigger on word characters after space
+        if char =~ /[a-zA-Z_]/
+          return true if before_cursor =~ /[\s\.\(]$/
+        end
+
+        false
+      end
+
+      # Check if character should commit completion
+      def should_commit?(char)
+        @commit_chars.include?(char)
+      end
+
+      # Get word at cursor position
+      def word_at_cursor(text, cursor_pos)
+        before = text[0...cursor_pos]
+        after = text[cursor_pos..-1] || ''
+
+        # Find word boundaries
+        word_start = before.rindex(/[^a-zA-Z0-9_]/) || -1
+        word_end = after.index(/[^a-zA-Z0-9_]/) || after.length
+
+        word = before[(word_start + 1)..-1] || ''
+        word += after[0...word_end]
+
+        word
+      end
+
+      # Get prefix for filtering
+      def prefix(text, cursor_pos)
+        before = text[0...cursor_pos]
+
+        # Get characters after last non-word char
+        match = before.match(/([a-zA-Z0-9_]*)$/)
+        match ? match[1] : ''
+      end
+    end
+  end
+end