feat: implement hover support for LSP

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: shyim

internal/lsp/hover.go

@@ -0,0 +1,37 @@
+package lsp
+
+import (
+	"context"
+	"path/filepath"
+
+	"github.com/shopware/shopware-lsp/internal/lsp/protocol"
+	"github.com/shopware/shopware-lsp/internal/php"
+)
+
+// hover handles textDocument/hover requests
+func (s *Server) hover(ctx context.Context, params *protocol.HoverParams) (*protocol.Hover, error) {
+	node, docText, ok := s.documentManager.GetNodeAtPosition(params.TextDocument.URI, params.Position.Line, params.Position.Character)
+	if ok {
+		params.Node = node
+		params.DocumentContent = docText.Text
+
+		if filepath.Ext(params.TextDocument.URI) == ".php" {
+			phpIndex, _ := s.GetIndexer("php.index")
+			ctx = phpIndex.(*php.PHPIndex).AddContext(ctx, node, docText.Text)
+		}
+	}
+
+	// Try each hover provider until one returns a result
+	for _, provider := range s.hoverProviders {
+		hover, err := provider.GetHover(ctx, params)
+		if err != nil {
+			continue
+		}
+		if hover != nil {
+			return hover, nil
+		}
+	}
+
+	// No hover information available
+	return nil, nil
+}

internal/lsp/protocol/hover.go

@@ -0,0 +1,51 @@
+package protocol
+
+import tree_sitter "github.com/tree-sitter/go-tree-sitter"
+
+// HoverParams represents the parameters for a hover request
+type HoverParams struct {
+	TextDocument struct {
+		URI string `json:"uri"`
+	} `json:"textDocument"`
+	Position struct {
+		Line      int `json:"line"`
+		Character int `json:"character"`
+	} `json:"position"`
+	WorkDoneToken interface{} `json:"workDoneToken,omitempty"`
+
+	// Custom fields for internal use (not part of LSP spec)
+	// These fields are used to pass document content to hover providers
+	DocumentContent []byte            `json:"-"`
+	Node            *tree_sitter.Node `json:"-"`
+}
+
+// Hover represents the result of a hover request
+type Hover struct {
+	// The hover's content
+	Contents MarkupContent `json:"contents"`
+
+	// An optional range inside the text document that is used to
+	// visualize the hover, e.g. by changing the background color
+	Range *Range `json:"range,omitempty"`
+}
+
+// MarkupContent represents a string value which content is interpreted based on its kind flag
+type MarkupContent struct {
+	// The type of the Markup
+	Kind MarkupKind `json:"kind"`
+
+	// The content itself
+	Value string `json:"value"`
+}
+
+// MarkupKind describes the content type that a client supports in various
+// result literals like `Hover`, `ParameterInfo` or `CompletionItem`
+type MarkupKind string
+
+const (
+	// PlainText plain text is supported as a content format
+	PlainText MarkupKind = "plaintext"
+
+	// Markdown markdown is supported as a content format
+	Markdown MarkupKind = "markdown"
+)

internal/lsp/server.go

@@ -27,6 +27,7 @@ type Server struct {
 	codeLensProviders    []CodeLensProvider
 	diagnosticsProviders []DiagnosticsProvider
 	codeActionProviders  []CodeActionProvider
+	hoverProviders       []HoverProvider
 	commandProviders     []CommandProvider
 	indexers             map[string]indexer.Indexer
 	commandMap           map[string]CommandFunc
@@ -46,6 +47,7 @@ func NewServer(filescanner *indexer.FileScanner, cacheDir, version string) *Serv
 		codeLensProviders:    make([]CodeLensProvider, 0),
 		diagnosticsProviders: make([]DiagnosticsProvider, 0),
 		codeActionProviders:  make([]CodeActionProvider, 0),
+		hoverProviders:       make([]HoverProvider, 0),
 		commandProviders:     make([]CommandProvider, 0),
 		indexers:             make(map[string]indexer.Indexer),
 		commandMap:           make(map[string]CommandFunc),
@@ -89,6 +91,11 @@ func (s *Server) RegisterCodeActionProvider(provider CodeActionProvider) {
 	s.codeActionProviders = append(s.codeActionProviders, provider)
 }
 
+// RegisterHoverProvider registers a hover provider with the server
+func (s *Server) RegisterHoverProvider(provider HoverProvider) {
+	s.hoverProviders = append(s.hoverProviders, provider)
+}
+
 // RegisterCommandProvider registers a command provider with the server
 func (s *Server) RegisterCommandProvider(provider CommandProvider) {
 	s.commandProviders = append(s.commandProviders, provider)
@@ -355,6 +362,13 @@ func (s *Server) handle(ctx context.Context, conn *jsonrpc2.Conn, req *jsonrpc2.
 		}
 		return s.codeLens(ctx, &params), nil
 
+	case "textDocument/hover":
+		var params protocol.HoverParams
+		if err := json.Unmarshal(*req.Params, &params); err != nil {
+			return nil, err
+		}
+		return s.hover(ctx, &params)
+
 	case "textDocument/diagnostic":
 		var params protocol.DiagnosticParams
 		if err := json.Unmarshal(*req.Params, &params); err != nil {
@@ -539,6 +553,7 @@ func (s *Server) initialize(ctx context.Context, params *protocol.InitializePara
 			},
 			"definitionProvider": true,
 			"referencesProvider": true,
+			"hoverProvider":      true,
 			"codeLensProvider": map[string]interface{}{
 				"resolveProvider": true,
 			},

internal/lsp/types.go

@@ -15,6 +15,12 @@ type CompletionProvider interface {
 	GetTriggerCharacters() []string
 }
 
+// HoverProvider is an interface for providing hover information
+type HoverProvider interface {
+	// GetHover returns hover information for the given parameters
+	GetHover(ctx context.Context, params *protocol.HoverParams) (*protocol.Hover, error)
+}
+
 // CodeLensProvider is an interface for providing code lenses
 type CodeLensProvider interface {
 	// GetCodeLenses returns code lenses for the given document