synthra 0.1.0

data/lib/synthra/lsp/server.rb

@@ -0,0 +1,689 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra Language Server Protocol (LSP) Implementation
+# =============================================================================
+#
+# Provides IDE features for Synthra schema files:
+# - Go to Definition for Ref(User.id) and schema references
+# - Real-time error reporting as you type
+# - Auto-completion for registered types, behaviors, and schemas
+# - Hover documentation for types and behaviors
+# - Code actions for common fixes
+#
+# Usage:
+#   # Start LSP server
+#   synthra lsp
+#
+#   # Or use with language server client
+#   ruby -Ilib lib/synthra/lsp/server.rb
+#
+# =============================================================================
+
+require "json"
+require "uri"
+
+module Synthra
+  module LSP
+    # Language Server Protocol server for Synthra
+    #
+    # Implements LSP 3.17 specification for Synthra schema files.
+    # Provides IDE features like go-to-definition, hover, completion, and diagnostics.
+    #
+    # @example Start server
+    #   server = Server.new
+    #   server.run
+    #
+    class Server
+      # Initialize LSP server
+      #
+      # @param input [IO] input stream (default: $stdin)
+      # @param output [IO] output stream (default: $stdout)
+      #
+      def initialize(input: $stdin, output: $stdout)
+        @input = input
+        @output = output
+        @registry = Registry.new
+        @workspace_roots = []
+        @documents = {} # URI => { content: String, version: Integer }
+      end
+
+      # Run the LSP server (main loop)
+      #
+      # Reads JSON-RPC messages from input and processes them.
+      #
+      def run
+        @running = true
+        begin
+          while @running
+            header = read_header
+            next unless header
+
+            content_length = header["Content-Length"]&.to_i
+            next unless content_length&.positive?
+
+            message = @input.read(content_length)
+            next unless message
+
+            process_message(JSON.parse(message))
+          end
+        rescue JSON::ParserError => e
+          send_error(-32700, "Parse error: #{e.message}")
+        rescue StandardError => e
+          send_error(-32603, "Internal error: #{e.message}")
+        end
+      end
+
+      private
+
+      # Read HTTP-style header from input
+      #
+      # @return [Hash, nil] header hash or nil if EOF
+      #
+      def read_header
+        header = {}
+        loop do
+          line = @input.gets
+          return nil if line.nil? || line.strip.empty?
+
+          key, value = line.split(":", 2)
+          header[key.strip] = value&.strip
+        end
+      end
+
+      # Process a JSON-RPC message
+      #
+      # @param message [Hash] parsed JSON-RPC message
+      #
+      def process_message(message)
+        id = message["id"]
+        method = message["method"]
+        params = message["params"] || {}
+
+        case method
+        when "initialize"
+          send_response(id, initialize_response(params))
+        when "initialized"
+          # Client is ready
+        when "textDocument/didOpen"
+          handle_did_open(params)
+        when "textDocument/didChange"
+          handle_did_change(params)
+        when "textDocument/didClose"
+          handle_did_close(params)
+        when "textDocument/definition"
+          send_response(id, handle_definition(params))
+        when "textDocument/hover"
+          send_response(id, handle_hover(params))
+        when "textDocument/completion"
+          send_response(id, handle_completion(params))
+        when "textDocument/diagnostic"
+          send_response(id, handle_diagnostic(params))
+        when "shutdown"
+          @running = false
+          send_response(id, nil)
+        when "exit"
+          @running = false
+        else
+          send_error(-32601, "Method not found: #{method}", id: id)
+        end
+      end
+
+      # Handle textDocument/didOpen notification
+      #
+      # @param params [Hash] notification parameters
+      #
+      def handle_did_open(params)
+        uri = params.dig("textDocument", "uri")
+        text = params.dig("textDocument", "text")
+        return unless uri && text
+
+        @documents[uri] = { content: text, version: 0 }
+        validate_document(uri)
+      end
+
+      # Handle textDocument/didChange notification
+      #
+      # @param params [Hash] notification parameters
+      #
+      def handle_did_change(params)
+        uri = params.dig("textDocument", "uri")
+        changes = params.dig("contentChanges") || []
+        version = params.dig("textDocument", "version")
+
+        return unless uri && @documents[uri]
+
+        # Apply changes (simplified - assumes full document replacement)
+        if changes.any?
+          @documents[uri][:content] = changes.last["text"]
+          @documents[uri][:version] = version if version
+          validate_document(uri)
+        end
+      end
+
+      # Handle textDocument/didClose notification
+      #
+      # @param params [Hash] notification parameters
+      #
+      def handle_did_close(params)
+        uri = params.dig("textDocument", "uri")
+        @documents.delete(uri) if uri
+      end
+
+      # Handle textDocument/definition request
+      #
+      # Returns location of definition for Ref(User.id) or schema references.
+      #
+      # @param params [Hash] request parameters
+      # @return [Hash, nil] location or nil if not found
+      #
+      def handle_definition(params)
+        uri = params.dig("textDocument", "uri")
+        position = params["position"]
+        return nil unless uri && position
+
+        doc = @documents[uri]
+        return nil unless doc
+
+        line = doc[:content].lines[position["line"]]
+        return nil unless line
+
+        # Find schema reference or Ref() call at cursor position
+        col = position["character"]
+
+        # Check for Ref(Schema.field) pattern
+        if line[0..col] =~ /Ref\(([A-Z]\w+)\.(\w+)\)/
+          schema_name = $1
+          field_name = $2
+
+          # Find schema definition in current or other files
+          schema_uri, schema_pos = find_schema_definition(schema_name, uri)
+          return nil unless schema_uri
+
+          # Find field definition within schema
+          field_pos = find_field_definition(schema_uri, schema_name, field_name)
+          return field_pos if field_pos
+
+          # Return schema definition if field not found
+          {
+            uri: schema_uri,
+            range: {
+              start: { line: schema_pos, character: 0 },
+              end: { line: schema_pos, character: schema_name.length }
+            }
+          }
+        # Check for schema type reference (e.g., "address: Address")
+        elsif line[0..col] =~ /:\s*([A-Z]\w+)(\?)?\s*$/
+          schema_name = $1
+          schema_uri, schema_pos = find_schema_definition(schema_name, uri)
+          return nil unless schema_uri
+
+          {
+            uri: schema_uri,
+            range: {
+              start: { line: schema_pos, character: 0 },
+              end: { line: schema_pos, character: schema_name.length }
+            }
+          }
+        else
+          nil
+        end
+      end
+
+      # Handle textDocument/hover request
+      #
+      # Returns documentation for types, behaviors, or schemas at cursor.
+      #
+      # @param params [Hash] request parameters
+      # @return [Hash, nil] hover information or nil
+      #
+      def handle_hover(params)
+        uri = params.dig("textDocument", "uri")
+        position = params["position"]
+        return nil unless uri && position
+
+        doc = @documents[uri]
+        return nil unless doc
+
+        line = doc[:content].lines[position["line"]]
+        return nil unless line
+
+        col = position["character"]
+        word = extract_word_at_position(line, col)
+
+        # Check for behavior annotation
+        if word.start_with?("@")
+          behavior_name = word[1..]
+          return hover_behavior(behavior_name)
+        end
+
+        # Check for type name
+        if Types::Registry.registered?(word)
+          return hover_type(word)
+        end
+
+        # Check for schema name
+        if word =~ /^[A-Z]/
+          schema_uri, _ = find_schema_definition(word, uri)
+          return hover_schema(word) if schema_uri
+        end
+
+        nil
+      end
+
+      # Handle textDocument/completion request
+      #
+      # Returns completion suggestions for types, behaviors, and schemas.
+      #
+      # @param params [Hash] request parameters
+      # @return [Hash] completion list
+      #
+      def handle_completion(params)
+        uri = params.dig("textDocument", "uri")
+        position = params["position"]
+        return { items: [] } unless uri && position
+
+        doc = @documents[uri]
+        return { items: [] } unless doc
+
+        line = doc[:content].lines[position["line"]]
+        return { items: [] } unless line
+
+        col = position["character"]
+        prefix = line[0..col]
+
+        items = []
+
+        # Behavior completions (@latency, @failure, etc.)
+        if prefix =~ /@(\w*)$/
+          prefix_text = $1
+          Behaviors::Registry.names.each do |name|
+            next unless name.to_s.start_with?(prefix_text)
+
+            items << {
+              label: "@#{name}",
+              kind: 14, # Keyword
+              documentation: behavior_documentation(name),
+              insertText: "@#{name} "
+            }
+          end
+        end
+
+        # Type completions
+        if prefix =~ /:\s*(\w*)$/
+          prefix_text = $1
+          Types::Registry.names.each do |name|
+            next unless name.start_with?(prefix_text)
+
+            items << {
+              label: name,
+              kind: 6, # Class
+              documentation: type_documentation(name),
+              insertText: name
+            }
+          end
+        end
+
+        # Schema completions (for Ref() or type references)
+        if prefix =~ /(Ref\(|:\s*)([A-Z]\w*)$/
+          prefix_text = $2
+          find_all_schemas(uri).each do |schema_name|
+            next unless schema_name.start_with?(prefix_text)
+
+            items << {
+              label: schema_name,
+              kind: 5, # Class
+              documentation: "Schema: #{schema_name}",
+              insertText: schema_name
+            }
+          end
+        end
+
+        { items: items }
+      end
+
+      # Handle textDocument/diagnostic request
+      #
+      # Returns validation errors and warnings for the document.
+      #
+      # @param params [Hash] request parameters
+      # @return [Hash] diagnostic list
+      #
+      def handle_diagnostic(params)
+        uri = params.dig("textDocument", "uri")
+        return { items: [] } unless uri
+
+        doc = @documents[uri]
+        return { items: [] } unless doc
+
+        diagnostics = validate_document(uri)
+        { items: diagnostics }
+      end
+
+      # Validate a document and return diagnostics
+      #
+      # @param uri [String] document URI
+      # @return [Array<Hash>] diagnostic items
+      #
+      def validate_document(uri)
+        doc = @documents[uri]
+        return [] unless doc
+
+        diagnostics = []
+
+        begin
+          # Parse the document
+          parser = Parser::Parser.new
+          ast_nodes = parser.parse(doc[:content])
+
+          # Load into registry for validation
+          temp_registry = Registry.new
+          ast_nodes.each do |node|
+            schema = node.to_schema
+            temp_registry.instance_variable_get(:@schemas)[schema.name] = schema
+          end
+
+          # Validate paths
+          validator = Validator::PathValidator.new(temp_registry)
+          errors = validator.validate
+
+          errors.each do |error|
+            diagnostics << {
+              range: {
+                start: { line: (error.line || 0) - 1, character: (error.column || 0) - 1 },
+                end: { line: (error.line || 0) - 1, character: (error.column || 0) }
+              },
+              severity: 1, # Error
+              message: error.message,
+              source: "Synthra"
+            }
+          end
+        rescue Errors::ParseError => e
+          diagnostics << {
+            range: {
+              start: { line: (e.line || 1) - 1, character: (e.column || 0) - 1 },
+              end: { line: (e.line || 1) - 1, character: (e.column || 0) }
+            },
+            severity: 1, # Error
+            message: e.message,
+            source: "Synthra"
+          }
+        rescue StandardError => e
+          diagnostics << {
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 0 }
+            },
+            severity: 1, # Error
+            message: "Parse error: #{e.message}",
+            source: "Synthra"
+          }
+        end
+
+        # Send diagnostics notification
+        send_notification("textDocument/publishDiagnostics", {
+          uri: uri,
+          diagnostics: diagnostics
+        })
+
+        diagnostics
+      end
+
+      # Find schema definition in workspace
+      #
+      # @param schema_name [String] schema name to find
+      # @param current_uri [String] current document URI
+      # @return [Array<String, Integer>, nil] [uri, line] or nil if not found
+      #
+      def find_schema_definition(schema_name, current_uri)
+        # Check current document first
+        doc = @documents[current_uri]
+        if doc
+          doc[:content].lines.each_with_index do |line, idx|
+            if line =~ /^#{Regexp.escape(schema_name)}:\s*$/
+              return [current_uri, idx]
+            end
+          end
+        end
+
+        # Check other documents in workspace
+        @documents.each do |uri, doc_data|
+          next if uri == current_uri
+
+          doc_data[:content].lines.each_with_index do |line, idx|
+            if line =~ /^#{Regexp.escape(schema_name)}:\s*$/
+              return [uri, idx]
+            end
+          end
+        end
+
+        nil
+      end
+
+      # Find field definition within a schema
+      #
+      # @param schema_uri [String] document URI containing schema
+      # @param schema_name [String] schema name
+      # @param field_name [String] field name to find
+      # @return [Hash, nil] location or nil if not found
+      #
+      def find_field_definition(schema_uri, schema_name, field_name)
+        doc = @documents[schema_uri]
+        return nil unless doc
+
+        in_schema = false
+        doc[:content].lines.each_with_index do |line, idx|
+          if line =~ /^#{Regexp.escape(schema_name)}:\s*$/
+            in_schema = true
+            next
+          end
+
+          break if in_schema && line !~ /^\s/ # End of schema
+
+          if in_schema && line =~ /^\s+#{Regexp.escape(field_name)}(\??):/
+            return {
+              uri: schema_uri,
+              range: {
+                start: { line: idx, character: line.index(field_name) },
+                end: { line: idx, character: line.index(field_name) + field_name.length }
+              }
+            }
+          end
+        end
+
+        nil
+      end
+
+      # Find all schema names in workspace
+      #
+      # @param current_uri [String] current document URI
+      # @return [Array<String>] schema names
+      #
+      def find_all_schemas(current_uri)
+        schemas = []
+
+        @documents.each do |uri, doc_data|
+          doc_data[:content].lines.each do |line|
+            if line =~ /^([A-Z]\w+):\s*$/
+              schemas << $1 unless schemas.include?($1)
+            end
+          end
+        end
+
+        schemas
+      end
+
+      # Extract word at cursor position
+      #
+      # @param line [String] line content
+      # @param col [Integer] column position
+      # @return [String] word at position
+      #
+      def extract_word_at_position(line, col)
+        # Find word boundaries
+        start = col
+        start -= 1 while start > 0 && line[start - 1] =~ /[\w@]/
+        finish = col
+        finish += 1 while finish < line.length && line[finish] =~ /[\w]/
+
+        line[start...finish] || ""
+      end
+
+      # Get hover information for a behavior
+      #
+      # @param name [String] behavior name
+      # @return [Hash, nil] hover information
+      #
+      def hover_behavior(name)
+        behavior_class = Behaviors::Registry.lookup(name.to_sym) rescue nil
+        return nil unless behavior_class
+
+        {
+          contents: {
+            kind: "markdown",
+            value: "**@#{name}**\n\nBehavior: #{behavior_class.name}"
+          }
+        }
+      end
+
+      # Get hover information for a type
+      #
+      # @param name [String] type name
+      # @return [Hash, nil] hover information
+      #
+      def hover_type(name)
+        {
+          contents: {
+            kind: "markdown",
+            value: "**#{name}**\n\nType: #{name}"
+          }
+        }
+      end
+
+      # Get hover information for a schema
+      #
+      # @param name [String] schema name
+      # @return [Hash, nil] hover information
+      #
+      def hover_schema(name)
+        {
+          contents: {
+            kind: "markdown",
+            value: "**#{name}**\n\nSchema definition"
+          }
+        }
+      end
+
+      # Get documentation for a behavior
+      #
+      # @param name [Symbol] behavior name
+      # @return [String] documentation string
+      #
+      def behavior_documentation(name)
+        "Behavior: @#{name}"
+      end
+
+      # Get documentation for a type
+      #
+      # @param name [String] type name
+      # @return [String] documentation string
+      #
+      def type_documentation(name)
+        "Type: #{name}"
+      end
+
+      # Initialize response
+      #
+      # @param params [Hash] initialize parameters
+      # @return [Hash] initialize response
+      #
+      def initialize_response(params)
+        @workspace_roots = [params.dig("workspaceFolders", 0, "uri")].compact
+
+        {
+          capabilities: {
+            textDocumentSync: {
+              openClose: true,
+              change: 1, # Full
+              willSave: false,
+              willSaveWaitUntil: false,
+              save: { includeText: false }
+            },
+            hoverProvider: true,
+            definitionProvider: true,
+            completionProvider: {
+              triggerCharacters: [":", "@", "(", "."]
+            },
+            diagnosticProvider: {
+              interFileDependencies: true,
+              workspaceDiagnostics: false
+            }
+          },
+          serverInfo: {
+            name: "Synthra LSP",
+            version: Synthra::VERSION
+          }
+        }
+      end
+
+      # Send JSON-RPC response
+      #
+      # @param id [Integer, String, nil] request ID
+      # @param result [Object] response result
+      #
+      def send_response(id, result)
+        message = {
+          jsonrpc: "2.0",
+          id: id,
+          result: result
+        }.compact
+
+        send_message(message)
+      end
+
+      # Send JSON-RPC error
+      #
+      # @param code [Integer] error code
+      # @param message [String] error message
+      # @param id [Integer, String, nil] request ID
+      #
+      def send_error(code, message, id: nil)
+        error = {
+          jsonrpc: "2.0",
+          id: id,
+          error: {
+            code: code,
+            message: message
+          }
+        }
+
+        send_message(error)
+      end
+
+      # Send JSON-RPC notification
+      #
+      # @param method [String] notification method
+      # @param params [Hash] notification parameters
+      #
+      def send_notification(method, params)
+        message = {
+          jsonrpc: "2.0",
+          method: method,
+          params: params
+        }
+
+        send_message(message)
+      end
+
+      # Send JSON-RPC message
+      #
+      # @param message [Hash] message to send
+      #
+      def send_message(message)
+        json = JSON.generate(message)
+        @output.write("Content-Length: #{json.bytesize}\r\n\r\n#{json}")
+        @output.flush
+      end
+    end
+  end
+end