fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/lsp/protocol.rb

@@ -0,0 +1,434 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gsd
+  module LSP
+    # LSP Protocol implementation
+    # Handles JSON-RPC message formatting and parsing
+    module Protocol
+      # Header constants
+      CONTENT_TYPE = 'application/vscode-jsonrpc; charset=utf-8'
+      HEADER_DELIMITER = "\r\n\r\n"
+
+      # Build a JSON-RPC request
+      def self.build_request(method, params, id = nil)
+        message = {
+          jsonrpc: '2.0',
+          method: method
+        }
+        message[:params] = params if params
+        message[:id] = id if id
+
+        message
+      end
+
+      # Build a JSON-RPC notification (no id)
+      def self.build_notification(method, params = nil)
+        message = {
+          jsonrpc: '2.0',
+          method: method
+        }
+        message[:params] = params if params
+
+        message
+      end
+
+      # Build a JSON-RPC response
+      def self.build_response(id, result = nil, error = nil)
+        message = {
+          jsonrpc: '2.0',
+          id: id
+        }
+
+        if error
+          message[:error] = error
+        else
+          message[:result] = result
+        end
+
+        message
+      end
+
+      # Parse raw message from server
+      def self.parse_message(data)
+        return nil if data.nil? || data.empty?
+
+        # Split headers and content
+        header_end = data.index(HEADER_DELIMITER)
+
+        # Try with just \n if \r\n not found
+        if header_end.nil?
+          header_end = data.index("\n\n")
+          header_delim = "\n\n"
+        else
+          header_delim = HEADER_DELIMITER
+        end
+
+        return nil unless header_end
+
+        headers = data[0...header_end]
+        content = data[header_end + header_delim.length..-1]
+
+        # Parse Content-Length
+        content_length = parse_content_length(headers)
+        return nil unless content_length
+
+        # Extract exactly content_length bytes
+        if content.length >= content_length
+          json_content = content[0...content_length]
+          remaining = content[content_length..-1]
+
+          begin
+            parsed = JSON.parse(json_content)
+            return { message: parsed, remaining: remaining }
+          rescue JSON::ParserError => e
+            warn "[LSP] JSON parse error: #{e.message}"
+            return nil
+          end
+        end
+
+        nil
+      end
+
+      # Parse Content-Length header
+      def self.parse_content_length(headers)
+        headers.each_line do |line|
+          if line =~ /^Content-Length:\s*(\d+)/i
+            return $1.to_i
+          end
+        end
+        nil
+      end
+
+      # Format message for transport
+      def self.format_message(message)
+        json = message.to_json
+        "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+      end
+
+      # Standard LSP methods
+      module Methods
+        INITIALIZE = 'initialize'
+        INITIALIZED = 'initialized'
+        SHUTDOWN = 'shutdown'
+        EXIT = 'exit'
+
+        # Text Document
+        TEXT_DOCUMENT_DID_OPEN = 'textDocument/didOpen'
+        TEXT_DOCUMENT_DID_CHANGE = 'textDocument/didChange'
+        TEXT_DOCUMENT_DID_CLOSE = 'textDocument/didClose'
+        TEXT_DOCUMENT_DID_SAVE = 'textDocument/didSave'
+        TEXT_DOCUMENT_COMPLETION = 'textDocument/completion'
+        TEXT_DOCUMENT_HOVER = 'textDocument/hover'
+        TEXT_DOCUMENT_DEFINITION = 'textDocument/definition'
+        TEXT_DOCUMENT_REFERENCES = 'textDocument/references'
+        TEXT_DOCUMENT_DOCUMENT_SYMBOL = 'textDocument/documentSymbol'
+        TEXT_DOCUMENT_FORMATTING = 'textDocument/formatting'
+        TEXT_DOCUMENT_RENAME = 'textDocument/rename'
+
+        # Workspace
+        WORKSPACE_SYMBOL = 'workspace/symbol'
+        WORKSPACE_EXECUTE_COMMAND = 'workspace/executeCommand'
+        WORKSPACE_DID_CHANGE_CONFIGURATION = 'workspace/didChangeConfiguration'
+
+        # Diagnostics
+        TEXT_DOCUMENT_PUBLISH_DIAGNOSTICS = 'textDocument/publishDiagnostics'
+      end
+
+      # Error codes
+      module ErrorCodes
+        PARSE_ERROR = -32700
+        INVALID_REQUEST = -32600
+        METHOD_NOT_FOUND = -32601
+        INVALID_PARAMS = -32602
+        INTERNAL_ERROR = -32603
+        SERVER_ERROR_START = -32099
+        SERVER_ERROR_END = -32000
+        SERVER_NOT_INITIALIZED = -32002
+        UNKNOWN_ERROR_CODE = -32001
+
+        # LSP specific
+        REQUEST_CANCELLED = -32800
+        CONTENT_MODIFIED = -32801
+      end
+    end
+
+    # Position in a document
+    class Position
+      attr_reader :line, :character
+
+      def initialize(line, character)
+        @line = line
+        @character = character
+      end
+
+      def to_h
+        { line: @line, character: @character }
+      end
+
+      def self.from_h(hash)
+        new(hash['line'] || hash[:line], hash['character'] || hash[:character])
+      end
+    end
+
+    # Range in a document
+    class Range
+      attr_reader :start, :end
+
+      def initialize(start_pos, end_pos)
+        @start = start_pos
+        @end = end_pos
+      end
+
+      def to_h
+        { start: @start.to_h, end: @end.to_h }
+      end
+
+      def self.from_h(hash)
+        start_pos = Position.from_h(hash['start'] || hash[:start])
+        end_pos = Position.from_h(hash['end'] || hash[:end])
+        new(start_pos, end_pos)
+      end
+    end
+
+    # Location (uri + range)
+    class Location
+      attr_reader :uri, :range
+
+      def initialize(uri, range)
+        @uri = uri
+        @range = range
+      end
+
+      def to_h
+        { uri: @uri, range: @range.to_h }
+      end
+    end
+
+    # Text document identifier
+    class TextDocumentIdentifier
+      attr_reader :uri
+
+      def initialize(uri)
+        @uri = uri
+      end
+
+      def to_h
+        { uri: @uri }
+      end
+    end
+
+    # Versioned text document identifier
+    class VersionedTextDocumentIdentifier
+      attr_reader :uri, :version
+
+      def initialize(uri, version)
+        @uri = uri
+        @version = version
+      end
+
+      def to_h
+        { uri: @uri, version: @version }
+      end
+    end
+
+    # Text document item
+    class TextDocumentItem
+      attr_reader :uri, :language_id, :version, :text
+
+      def initialize(uri, language_id, version, text)
+        @uri = uri
+        @language_id = language_id
+        @version = version
+        @text = text
+      end
+
+      def to_h
+        {
+          uri: @uri,
+          languageId: @language_id,
+          version: @version,
+          text: @text
+        }
+      end
+    end
+
+    # Text edit
+    class TextEdit
+      attr_reader :range, :new_text
+
+      def initialize(range, new_text)
+        @range = range
+        @new_text = new_text
+      end
+
+      def to_h
+        { range: @range.to_h, newText: @new_text }
+      end
+    end
+
+    # Diagnostic
+    class Diagnostic
+      attr_reader :range, :severity, :code, :source, :message
+
+      SEVERITY = {
+        error: 1,
+        warning: 2,
+        information: 3,
+        hint: 4
+      }.freeze
+
+      def initialize(range, message, severity: :error, code: nil, source: nil)
+        @range = range
+        @message = message
+        @severity = SEVERITY[severity] || severity
+        @code = code
+        @source = source
+      end
+
+      def to_h
+        h = {
+          range: @range.to_h,
+          message: @message,
+          severity: @severity
+        }
+        h[:code] = @code if @code
+        h[:source] = @source if @source
+        h
+      end
+
+      def self.from_h(hash)
+        range = Range.from_h(hash['range'] || hash[:range])
+        severity = hash['severity'] || hash[:severity]
+        code = hash['code'] || hash[:code]
+        source = hash['source'] || hash[:source]
+        message = hash['message'] || hash[:message]
+
+        new(range, message, severity: severity, code: code, source: source)
+      end
+    end
+
+    # Completion item
+    class CompletionItem
+      attr_reader :label, :kind, :detail, :documentation, :insert_text
+
+      KINDS = {
+        text: 1,
+        method: 2,
+        function: 3,
+        constructor: 4,
+        field: 5,
+        variable: 6,
+        class: 7,
+        interface: 8,
+        module: 9,
+        property: 10,
+        unit: 11,
+        value: 12,
+        enum: 13,
+        keyword: 14,
+        snippet: 15,
+        color: 16,
+        file: 17,
+        reference: 18
+      }.freeze
+
+      def initialize(label, kind: :text, detail: nil, documentation: nil, insert_text: nil)
+        @label = label
+        @kind = KINDS[kind] || kind
+        @detail = detail
+        @documentation = documentation
+        @insert_text = insert_text || label
+      end
+
+      def to_h
+        h = {
+          label: @label,
+          kind: @kind
+        }
+        h[:detail] = @detail if @detail
+        h[:documentation] = @documentation if @documentation
+        h[:insertText] = @insert_text if @insert_text
+        h
+      end
+
+      def self.from_h(hash)
+        label = hash['label'] || hash[:label]
+        kind = hash['kind'] || hash[:kind]
+        detail = hash['detail'] || hash[:detail]
+        documentation = hash['documentation'] || hash[:documentation]
+        insert_text = hash['insertText'] || hash['insertText] || hash[:insertText]
+
+        new(label, kind: kind, detail: detail, documentation: documentation, insert_text: insert_text)
+      end
+    end
+
+    # Hover
+    class Hover
+      attr_reader :contents, :range
+
+      def initialize(contents, range: nil)
+        @contents = contents
+        @range = range
+      end
+
+      def to_h
+        h = { contents: @contents }
+        h[:range] = @range.to_h if @range
+        h
+      end
+
+      def self.from_h(hash)
+        contents = hash['contents'] || hash[:contents]
+        range = hash['range'] || hash[:range]
+        range = Range.from_h(range) if range
+
+        new(contents, range: range)
+      end
+    end
+
+    # Symbol information
+    class SymbolInformation
+      attr_reader :name, :kind, :location, :container_name
+
+      SYMBOL_KINDS = {
+        file: 1,
+        module: 2,
+        namespace: 3,
+        package: 4,
+        class: 5,
+        method: 6,
+        property: 7,
+        field: 8,
+        constructor: 9,
+        enum: 10,
+        interface: 11,
+        function: 12,
+        variable: 13,
+        constant: 14,
+        string: 15,
+        number: 16,
+        boolean: 17,
+        array: 18
+      }.freeze
+
+      def initialize(name, kind, location, container_name: nil)
+        @name = name
+        @kind = SYMBOL_KINDS[kind] || kind
+        @location = location
+        @container_name = container_name
+      end
+
+      def to_h
+        h = {
+          name: @name,
+          kind: @kind,
+          location: @location.to_h
+        }
+        h[:containerName] = @container_name if @container_name
+        h
+      end
+    end
+  end
+end

data/lib/gsd/lsp/server_manager.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module Gsd
+  module LSP
+    # ServerManager - Manages multiple LSP servers for different languages
+    class ServerManager
+      attr_reader :clients, :language_map
+
+      # Default LSP server configurations
+      DEFAULT_SERVERS = {
+        ruby: {
+          command: 'ruby-lsp',
+          args: [],
+          extensions: ['.rb', '.rake', '.gemspec'],
+          name: 'Ruby LSP'
+        },
+        python: {
+          command: 'pylsp',
+          args: [],
+          extensions: ['.py', '.pyw'],
+          name: 'Python LSP'
+        },
+        javascript: {
+          command: 'typescript-language-server',
+          args: ['--stdio'],
+          extensions: ['.js', '.jsx', '.mjs'],
+          name: 'TypeScript LSP'
+        },
+        typescript: {
+          command: 'typescript-language-server',
+          args: ['--stdio'],
+          extensions: ['.ts', '.tsx'],
+          name: 'TypeScript LSP'
+        },
+        json: {
+          command: 'vscode-json-language-server',
+          args: ['--stdio'],
+          extensions: ['.json'],
+          name: 'JSON LSP'
+        },
+        html: {
+          command: 'vscode-html-language-server',
+          args: ['--stdio'],
+          extensions: ['.html', '.htm'],
+          name: 'HTML LSP'
+        },
+        css: {
+          command: 'vscode-css-language-server',
+          args: ['--stdio'],
+          extensions: ['.css', '.scss', '.sass', '.less'],
+          name: 'CSS LSP'
+        },
+        go: {
+          command: 'gopls',
+          args: [],
+          extensions: ['.go'],
+          name: 'Go LSP'
+        },
+        rust: {
+          command: 'rust-analyzer',
+          args: [],
+          extensions: ['.rs'],
+          name: 'Rust LSP'
+        }
+      }.freeze
+
+      def initialize
+        @clients = {}
+        @language_map = {}
+        @mutex = Mutex.new
+        @config = DEFAULT_SERVERS.dup
+      end
+
+      # Configure a language server
+      def configure(language, command:, args: [], extensions: [])
+        @config[language] = {
+          command: command,
+          args: args,
+          extensions: extensions,
+          name: language.to_s.capitalize + ' LSP'
+        }
+      end
+
+      # Get or start client for a file
+      def client_for_file(file_path)
+        language = detect_language(file_path)
+        return nil unless language
+
+        client_for_language(language)
+      end
+
+      # Get or start client for a language
+      def client_for_language(language)
+        language = language.to_sym
+
+        @mutex.synchronize do
+          return @clients[language] if @clients[language]&.running?
+
+          config = @config[language]
+          return nil unless config
+
+          # Check if server is available
+          return nil unless server_available?(config[:command])
+
+          # Create and start client
+          client = Client.new(config[:command], config[:args])
+          client.on_diagnostics = method(:handle_diagnostics)
+          client.on_log_message = method(:handle_log_message)
+
+          if client.start
+            @clients[language] = client
+            client
+          else
+            nil
+          end
+        end
+      end
+
+      # Stop all servers
+      def stop_all
+        @mutex.synchronize do
+          @clients.each do |language, client|
+            begin
+              client.stop
+            rescue StandardError => e
+              warn "[LSP] Error stopping #{language} server: #{e.message}"
+            end
+          end
+
+          @clients.clear
+        end
+      end
+
+      # Stop specific language server
+      def stop_language(language)
+        @mutex.synchronize do
+          client = @clients.delete(language.to_sym)
+          client&.stop
+        end
+      end
+
+      # Check if server is running for language
+      def running?(language)
+        client = @clients[language.to_sym]
+        client&.running? || false
+      end
+
+      # List running servers
+      def running
+        @clients.select { |_, client| client.running? }.keys
+      end
+
+      # List configured languages
+      def configured_languages
+        @config.keys
+      end
+
+      # Get server info for language
+      def server_info(language)
+        client = @clients[language.to_sym]
+        return nil unless client
+
+        {
+          name: @config[language.to_sym]&.[](:name),
+          running: client.running?,
+          state: client.state,
+          server_info: client.server_info,
+          capabilities: client.capabilities
+        }
+      end
+
+      # Detect language from file extension
+      def detect_language(file_path)
+        ext = File.extname(file_path).downcase
+
+        @config.each do |language, config|
+          return language if config[:extensions]&.include?(ext)
+        end
+
+        # Fallback based on content
+        detect_from_content(file_path)
+      end
+
+      # Check if LSP server command is available
+      def server_available?(command)
+        system("which #{command} > /dev/null 2>&1") ||
+          system("where #{command} > /dev/null 2>&1")
+      rescue StandardError
+        false
+      end
+
+      # Get all available servers
+      def available_servers
+        @config.select { |_, config| server_available?(config[:command]) }.keys
+      end
+
+      # Send notification to all running servers
+      def broadcast_notification(method, params = nil)
+        @clients.each do |language, client|
+          begin
+            client.notify(method, params) if client.running?
+          rescue StandardError => e
+            warn "[LSP] Error broadcasting to #{language}: #{e.message}"
+          end
+        end
+      end
+
+      # Reload configuration
+      def reload_config
+        # Stop all running servers
+        stop_all
+
+        # Reset to defaults
+        @config = DEFAULT_SERVERS.dup
+      end
+
+      private
+
+      def detect_from_content(file_path)
+        return nil unless File.exist?(file_path)
+
+        first_line = File.open(file_path, &:gets)
+        return nil unless first_line
+
+        # Shebang detection
+        if first_line.start_with?('#!')
+          case first_line
+          when /ruby/ then :ruby
+          when /python/ then :python
+          when /node/ then :javascript
+          when /bash|sh/ then :shell
+          else nil
+          end
+        else
+          nil
+        end
+      rescue StandardError
+        nil
+      end
+
+      def handle_diagnostics(uri, diagnostics)
+        # Broadcast to interested parties via hooks
+        Gsd::Plugins::Hooks.instance.trigger('lsp.diagnostics', uri, diagnostics)
+      end
+
+      def handle_log_message(type, message)
+        level = case type
+                when 1 then 'ERROR'
+                when 2 then 'WARNING'
+                when 3 then 'INFO'
+                when 4 then 'LOG'
+                else 'UNKNOWN'
+                end
+
+        warn "[LSP] #{level}: #{message}"
+      end
+    end
+
+    # LanguageServer - Per-language server wrapper
+    class LanguageServer
+      attr_reader :language, :client, :config
+
+      def initialize(language, config)
+        @language = language
+        @config = config
+        @client = nil
+      end
+
+      def start
+        return true if running?
+
+        @client = Client.new(@config[:command], @config[:args])
+        @client.start
+      end
+
+      def stop
+        @client&.stop
+        @client = nil
+      end
+
+      def running?
+        @client&.running? || false
+      end
+
+      def capabilities
+        @client&.capabilities || {}
+      end
+    end
+  end
+end