Commit 958e33f - qwe-editor

Merge: Better LSP integration

Author	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-05-20 01:52:03 +0200
Committer	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-05-20 02:39:04 +0200
Commit	`958e33ff5ca4e6d2e2fd4e29b11d01e7c08badb7` (patch)

`-rw-r--r--`	editor.go	216
`-rw-r--r--`	ftypes.go	34
`-rw-r--r--`	kevent.go	2
`-rw-r--r--`	lsp.go	506

4 files changed, 529 insertions, 229 deletions

diff --git a/editor.go b/editor.go
...
176	return result.String()	176	return result.String()
177	}	177	}
178		178
		179	func (e *Editor) wrapText(text string, maxWidth int) []string {
		180	var lines []string
		181	paragraphs := strings.Split(text, "\n")
		182
		183	for _, p := range paragraphs {
		184	words := strings.Fields(p)
		185	if len(words) == 0 {
		186	lines = append(lines, "")
		187	continue
		188	}
		189
		190	currentLine := ""
		191	for _, word := range words {
		192	if len(currentLine)+len(word)+1 <= maxWidth {
		193	if currentLine == "" {
		194	currentLine = word
		195	} else {
		196	currentLine += " " + word
		197	}
		198	} else {
		199	if currentLine != "" {
		200	lines = append(lines, currentLine)
		201	}
		202	// If a single word is longer than maxWidth, we have to break it
		203	for len(word) > maxWidth {
		204	lines = append(lines, word[:maxWidth])
		205	word = word[maxWidth:]
		206	}
		207	currentLine = word
		208	}
		209	}
		210	if currentLine != "" {
		211	lines = append(lines, currentLine)
		212	}
		213	}
		214	return lines
		215	}
		216
179	// NewEditor creates a new editor instance with a default empty buffer.	217	// NewEditor creates a new editor instance with a default empty buffer.
180	func NewEditor(devMode bool) *Editor {	218	func NewEditor(devMode bool) *Editor {
181	e := &Editor{	219	e := &Editor{
...
1735	}	1773	}
1736		1774
1737	e.pushJump()	1775	e.pushJump()
		1776
		1777	// Sync buffer content with LSP server before requesting definition.
		1778	b.lspClient.SendDidChange(b.toString())
1738		1779
1739	locs, err := b.lspClient.Definition(b.PrimaryCursor().Y, b.PrimaryCursor().X)	1780	locs, err := b.lspClient.Definition(b.PrimaryCursor().Y, b.PrimaryCursor().X)
1740	if err != nil {	1781	if err != nil {
...
4588	e.message = "Requesting signature..."	4629	e.message = "Requesting signature..."
4589	e.draw()	4630	e.draw()
4590		4631
		4632	// Sync buffer content with LSP server before requesting hover.
		4633	b.lspClient.SendDidChange(b.toString())
		4634
4591	cursor := b.PrimaryCursor()	4635	cursor := b.PrimaryCursor()
4592	content, err := b.lspClient.Hover(cursor.Y, cursor.X)	4636	content, err := b.lspClient.Hover(cursor.Y, cursor.X)
4593	if err != nil {	4637	if err != nil {
...
4608		4652
4609	e.message = "Requesting completions..."	4653	e.message = "Requesting completions..."
4610	e.draw()	4654	e.draw()
		4655
		4656	// Sync buffer content with LSP server before requesting completions.
		4657	b.lspClient.SendDidChange(b.toString())
4611		4658
4612	cursor := b.PrimaryCursor()	4659	cursor := b.PrimaryCursor()
4613	items, err := b.lspClient.Completion(cursor.Y, cursor.X)	4660	items, err := b.lspClient.Completion(cursor.Y, cursor.X)
...
4626	e.autocompleteScroll = 0	4673	e.autocompleteScroll = 0
4627	e.showAutocomplete = true	4674	e.showAutocomplete = true
4628	e.message = ""	4675	e.message = ""
		4676
		4677	e.resolveSelectedCompletion()
		4678	}
		4679
		4680	func (e *Editor) resolveSelectedCompletion() {
		4681	b := e.activeBuffer()
		4682	if b == nil \|\| b.lspClient == nil {
		4683	return
		4684	}
		4685
		4686	if e.autocompleteIndex < 0 \|\| e.autocompleteIndex >= len(e.autocompleteItems) {
		4687	return
		4688	}
		4689
		4690	item := e.autocompleteItems[e.autocompleteIndex]
		4691
		4692	// If it already has documentation and it's not a resolve-only item, maybe skip?
		4693	// But clangd often sends partial info.
		4694
		4695	go func(index int, it CompletionItem) {
		4696	resolved, err := b.lspClient.ResolveCompletion(it)
		4697	if err == nil {
		4698	// Update the item in the list if the index is still the same
		4699	if e.autocompleteIndex == index {
		4700	e.autocompleteItems[index] = resolved
		4701	termbox.Interrupt() // Redraw
		4702	}
		4703	}
		4704	}(e.autocompleteIndex, item)
4629	}	4705	}
4630		4706
4631	func (e *Editor) drawAutocompletePopup() {	4707	func (e *Editor) drawAutocompletePopup() {
...
4639	return	4715	return
4640	}	4716	}
4641		4717
4642	// Calculate max label width for alignment	4718	// Helper to get extra info (signature or type) for an item
4643	maxLabelWidth := 0	4719	getExtraInfo := func(item CompletionItem) string {
4644	for _, item := range e.autocompleteItems {	4720	info := ""
4645	if len(item.Label) > maxLabelWidth {	4721
4646	maxLabelWidth = len(item.Label)	4722	// 1. Try LabelDetails (standard in newer LSP)
		4723	if item.LabelDetails != nil {
		4724	// For functions, Detail usually has the parameters: (a, b int)
		4725	// For variables, Description usually has the type: int
		4726	if item.Kind == 2 \|\| item.Kind == 3 { // Method or Function
		4727	if item.LabelDetails.Detail != "" {
		4728	info = item.LabelDetails.Detail
		4729	} else if item.LabelDetails.Description != "" {
		4730	info = item.LabelDetails.Description
		4731	}
		4732	} else {
		4733	// For variables/others, prefer Description (type)
		4734	if item.LabelDetails.Description != "" {
		4735	info = item.LabelDetails.Description
		4736	} else if item.LabelDetails.Detail != "" {
		4737	info = item.LabelDetails.Detail
		4738	}
		4739	}
4647	}	4740	}
		4741
		4742	// 2. Fallback to Detail if still empty
		4743	if info == "" && item.Detail != "" {
		4744	info = item.Detail
		4745	// Some servers put the whole label in the detail, strip it if so
		4746	cleanLabel := item.Label
		4747	for strings.HasPrefix(cleanLabel, "•") \|\| strings.HasPrefix(cleanLabel, " ") {
		4748	cleanLabel = strings.TrimPrefix(cleanLabel, "•")
		4749	cleanLabel = strings.TrimPrefix(cleanLabel, " ")
		4750	}
		4751	if strings.HasPrefix(info, cleanLabel) {
		4752	info = strings.TrimSpace(strings.TrimPrefix(info, cleanLabel))
		4753	}
		4754	}
		4755
		4756	return strings.TrimSpace(info)
4648	}	4757	}
4649		4758
4650	// Calculate total width: label + separator + detail	4759	// Calculate max width for the combined display
4651	maxWidth := 0	4760	maxTotalWidth := 0
4652	for _, item := range e.autocompleteItems {	4761	type itemDisplay struct {
4653	displayText := item.Label	4762	label string
4654	if item.Detail != "" {	4763	sig string
4655	// Pad label to align, then add arrow and detail	4764	}
4656	padding := maxLabelWidth - len(item.Label)	4765	displayItems := make([]itemDisplay, len(e.autocompleteItems))
4657	displayText = item.Label + strings.Repeat(" ", padding) + " " + item.Detail	4766
		4767	for i, item := range e.autocompleteItems {
		4768	label := item.Label
		4769	for strings.HasPrefix(label, "•") \|\| strings.HasPrefix(label, " ") {
		4770	label = strings.TrimPrefix(label, "•")
		4771	label = strings.TrimPrefix(label, " ")
4658	}	4772	}
4659	if len(displayText) > maxWidth {	4773
4660	maxWidth = len(displayText)	4774	extra := getExtraInfo(item)
		4775	displayItems[i] = itemDisplay{label: label, sig: extra}
		4776
		4777	width := len(label)
		4778	if extra != "" {
		4779	width += len(extra) + 1 // +1 for spacing
		4780	}
		4781	if width > maxTotalWidth {
		4782	maxTotalWidth = width
4661	}	4783	}
4662	}	4784	}
4663		4785
4664	// Cap width to terminal width	4786	maxWidth := maxTotalWidth
4665	if maxWidth > w-10 {	4787	if maxWidth > 80 {
4666	maxWidth = w - 10	4788	maxWidth = 80
		4789	}
		4790	// Leave space for gutter and borders
		4791	if maxWidth > w-Config.GutterWidth-4 {
		4792	maxWidth = w - Config.GutterWidth - 4
4667	}	4793	}
4668		4794
4669	popupWidth := maxWidth + 2	4795	popupWidth := maxWidth + 2
...
4680	startX := cursorScreenX	4806	startX := cursorScreenX
4681	startY := cursorScreenY + 1	4807	startY := cursorScreenY + 1
4682		4808
4683	// Adjust if out of bounds
4684	if startY+popupHeight > h-1 {	4809	if startY+popupHeight > h-1 {
4685	startY = cursorScreenY - popupHeight	4810	startY = cursorScreenY - popupHeight
4686	}	4811	}
...
4691	startX = 0	4816	startX = 0
4692	}	4817	}
4693		4818
4694	fg, bg := GetThemeColor(ColorAutocompleteWindow)	4819	_, bg := GetThemeColor(ColorAutocompleteWindow)
4695	selFg, selBg := GetThemeColor(ColorAutocompleteSelected)	4820	selFg, selBg := GetThemeColor(ColorAutocompleteSelected)
		4821
		4822	blackFg := termbox.ColorBlack
		4823	darkGrayFg := termbox.Attribute(244) // Dark gray in 256-color palette
4696		4824
4697	// Draw background and content	4825	// Draw background and content
4698	for y := 0; y < popupHeight; y++ {	4826	for y := 0; y < popupHeight; y++ {
4699	itemIdx := y + e.autocompleteScroll	4827	itemIdx := y + e.autocompleteScroll
4700	if itemIdx >= len(e.autocompleteItems) {	4828	if itemIdx >= len(displayItems) {
4701	break	4829	break
4702	}	4830	}
4703	item := e.autocompleteItems[itemIdx]	4831	item := displayItems[itemIdx]
		4832
		4833	currentBg := bg
		4834	labelFg := blackFg
		4835	sigFg := darkGrayFg
4704		4836
4705	currentFg, currentBg := fg, bg
4706	if itemIdx == e.autocompleteIndex {	4837	if itemIdx == e.autocompleteIndex {
4707	currentFg, currentBg = selFg, selBg	4838	currentBg = selBg
		4839	labelFg = selFg
		4840	sigFg = selFg // Use selected foreground for both in selection
4708	}	4841	}
4709		4842
4710	// Fill line	4843	// Fill line
4711	for x := 0; x < popupWidth; x++ {	4844	for x := 0; x < popupWidth; x++ {
4712	termbox.SetCell(startX+x, startY+y, ' ', currentFg, currentBg)	4845	termbox.SetCell(startX+x, startY+y, ' ', labelFg, currentBg)
4713	}	4846	}
4714		4847
4715	// Draw label and detail (signature) with alignment	4848	// Draw label
4716	displayText := item.Label	4849	lx := 0
4717	if item.Detail != "" {	4850	for _, r := range item.label {
4718	// Pad label to align with others	4851	if lx < maxWidth {
4719	padding := maxLabelWidth - len(item.Label)	4852	termbox.SetCell(startX+1+lx, startY+y, r, labelFg, currentBg)
4720	displayText = item.Label + strings.Repeat(" ", padding) + " " + item.Detail	4853	lx++
		4854	}
4721	}	4855	}
4722	if len(displayText) > maxWidth {	4856
4723	displayText = displayText[:maxWidth-3] + "..."	4857	// Draw signature if it fits
4724	}	4858	if item.sig != "" && lx < maxWidth-1 {
4725	for j, r := range displayText {	4859	termbox.SetCell(startX+1+lx, startY+y, ' ', sigFg, currentBg)
4726	termbox.SetCell(startX+1+j, startY+y, r, currentFg, currentBg)	4860	lx++
		4861	for _, r := range item.sig {
		4862	if lx < maxWidth {
		4863	termbox.SetCell(startX+1+lx, startY+y, r, sigFg, currentBg)
		4864	lx++
		4865	}
		4866	}
4727	}	4867	}
4728	}	4868	}
4729	}	4869	}
...
4749		4889
4750	// Text to insert	4890	// Text to insert
4751	insertText := item.InsertText	4891	insertText := item.InsertText
4752	if insertText == "" {	4892	if item.TextEdit != nil {
		4893	insertText = item.TextEdit.NewText
		4894	} else if insertText == "" {
4753	insertText = item.Label	4895	insertText = item.Label
4754	}	4896	}
4755		4897
...

 // FileType represents the configuration for a specific programming language.
 type FileType struct {
 	Name             string   // Display name of the file type.
+	LanguageID       string   // LSP language identifier (e.g., "cpp", "typescriptreact").
 	Extensions       []string // File extensions (e.g., .go, .py) or filenames (e.g., Makefile).
 	UseTabs          bool     // Whether to use tabs for indentation.
 	Comment          string   // Single-line comment prefix (e.g., // or #).
 // fileTypes is a global list of all supported languages in the editor.
 var fileTypes = []*FileType{
 	{
-		Name:       "Go",
+		Name:           "Go",
-		Extensions: []string{".go"},
+		LanguageID:     "go",
-		UseTabs:    true,
+		Extensions:     []string{".go"},
-		Comment:    "//",
+		UseTabs:        true,
-		TabWidth:   Config.DefaultTabWidth,
+		Comment:        "//",
-		EnableLSP:  true,
+		TabWidth:       Config.DefaultTabWidth,
-		LSPCommand: "gopls",
+		EnableLSP:      true,
+		LSPCommand:     "gopls",
+		LSPCommandArgs: []string{"serve"},
 	},
 	{
 		Name:       "C",
+		LanguageID: "c",
 		Extensions: []string{".c", ".h"},
 		UseTabs:    true,
 		Comment:    "//",
 	},
 	{
 		Name:       "C++",
+		LanguageID: "cpp",
 		Extensions: []string{".cpp", ".hpp", ".cc", ".hh", ".cxx", ".hxx"},
 		UseTabs:    true,
 		Comment:    "//",
 	},
 	{
 		Name:           "JavaScript",
+		LanguageID:     "javascript",
 		Extensions:     []string{".js"},
 		UseTabs:        true,
 		Comment:        "//",
 	},
 	{
 		Name:           "TypeScript",
+		LanguageID:     "typescript",
 		Extensions:     []string{".ts"},
 		UseTabs:        true,
 		Comment:        "//",
 	},
 	{
 		Name:           "TSX",
+		LanguageID:     "typescriptreact",
 		Extensions:     []string{".tsx"},
 		UseTabs:        true,
 		Comment:        "//",
 	},
 	{
 		Name:           "Python",
+		LanguageID:     "python",
 		Extensions:     []string{".py"},
 		UseTabs:        false,
 		Comment:        "#",
 		TabWidth:       Config.DefaultTabWidth,
+		EnableLSP:      true,
 		LSPCommand:     "pyright-langserver",
 		LSPCommandArgs: []string{"--stdio"},
 	},
 	{
 		Name:       "Bash",
+		LanguageID: "shellscript",
 		Extensions: []string{".sh"},
 		UseTabs:    true,
 		Comment:    "#",
 	},
 	{
 		Name:       "CSS",
+		LanguageID: "css",
 		Extensions: []string{".css"},
 		UseTabs:    false,
 		Comment:    "//",
 	},
 	{
 		Name:       "Dockerfile",
+		LanguageID: "dockerfile",
 		Extensions: []string{".dockerfile", "Dockerfile"},
 		UseTabs:    false,
 		Comment:    "#",
 	},
 	{
 		Name:       "HTML",
+		LanguageID: "html",
 		Extensions: []string{".html", ".htm"},
 		UseTabs:    false,
 		Comment:    "",
 	},
 	{
 		Name:       "Lua",
+		LanguageID: "lua",
 		Extensions: []string{".lua"},
 		UseTabs:    true,
 		Comment:    "--",
 	},
 	{
 		Name:       "Markdown",
+		LanguageID: "markdown",
 		Extensions: []string{".md", ".markdown"},
 		UseTabs:    false,
 		Comment:    "",
 	},
 	{
 		Name:       "PHP",
+		LanguageID: "php",
 		Extensions: []string{".php"},
 		UseTabs:    true,
 		Comment:    "//",
 	},
 	{
 		Name:       "SQL",
+		LanguageID: "sql",
 		Extensions: []string{".sql"},
 		UseTabs:    true,
 		Comment:    "--",
 	},
 	{
 		Name:       "Makefile",
+		LanguageID: "makefile",
 		Extensions: []string{".make", "Makefile", "makefile"},
 		UseTabs:    true,
 		Comment:    "#",
 	},
 	{
 		Name:       "Text",
+		LanguageID: "plaintext",
 		Extensions: []string{},
 		UseTabs:    false,
 		Comment:    "",

 			if e.autocompleteIndex >= e.autocompleteScroll+10 {
 				e.autocompleteScroll = e.autocompleteIndex - 9
 			}
+			e.resolveSelectedCompletion()
 			return
 		case termbox.KeyArrowDown:
 			e.autocompleteIndex++
 			if e.autocompleteIndex >= e.autocompleteScroll+10 {
 				e.autocompleteScroll = e.autocompleteIndex - 9
 			}
+			e.resolveSelectedCompletion()
 			return
 		case termbox.KeyEnter:
 			e.insertCompletion(e.autocompleteItems[e.autocompleteIndex])



  
	responses     map[int64]chan map[string]interface{} // Map of request IDs to response channels.
	responseMutex sync.Mutex
	writeMutex    sync.Mutex // Protects concurrent writes to stdin.
	fileType      *FileType  // Associated file type for language ID.
}
  
// Position in a document (0-based line and character).

  
// CompletionItem represents a suggestion for completion.
type CompletionItem struct {
	Label         string               `json:"label"`
	LabelDetails  *CompletionItemLabel `json:"labelDetails"`
	Kind          int                  `json:"kind"`
	Detail        string               `json:"detail"`
	Documentation interface{}          `json:"documentation"`
	InsertText    string               `json:"insertText"`
	FilterText    string               `json:"filterText"`
	TextEdit      *TextEdit            `json:"textEdit"`
	Data          interface{}          `json:"data"` // Opaque data for resolve request
}
  
type CompletionItemLabel struct {
	Detail      string `json:"detail"`      // e.g. (int a, int b)
	Description string `json:"description"` // e.g. int
}
  
type TextEdit struct {
	Range   Range  `json:"range"`
	NewText string `json:"newText"`
}
  
// CompletionList represents a collection of completion items.

	// Launch the language server's executable.
	client.cmd = exec.Command(ft.LSPCommand, ft.LSPCommandArgs...)
  
	// Suppress the server's own internal log messages (stderr) and redirect to logCallback.
	stderr, err := client.cmd.StderrPipe()
	if err == nil {
		go func() {
			scanner := bufio.NewScanner(stderr)
			for scanner.Scan() {
				if client.logCallback != nil {
					client.logCallback("LSP-stderr", scanner.Text())
				}
			}
		}()
	}
  
	client.stdin, err = client.cmd.StdinPipe()

	if err != nil {
		return nil, err
	}
  
	// Set working directory to the project root to help server find config files and resolve relative paths.
	client.cmd.Dir = findProjectRoot(absPath)
  
	if err := client.cmd.Start(); err != nil {
		return nil, err

	return atomic.AddInt64(&c.messageID, 1)
}
  
// Request sends a JSON-RPC request and waits for a response (up to 5s).
func (c *LSPClient) Request(method string, params interface{}) (map[string]interface{}, error) {
	id := c.nextID()
	responseChan := make(chan map[string]interface{}, 1)
	c.responseMutex.Lock()
	c.responses[id] = responseChan
	c.responseMutex.Unlock()
  
	if err := c.sendRequestWithID(id, method, params); err != nil {
		c.responseMutex.Lock()
		delete(c.responses, id)
		c.responseMutex.Unlock()
		return nil, err
	}
  
	select {
	case resp := <-responseChan:
		if errVal, ok := resp["error"]; ok {
			return nil, fmt.Errorf("LSP error: %v", errVal)
		}
		return resp, nil
	case <-time.After(10 * time.Second):
		c.responseMutex.Lock()
		delete(c.responses, id)
		c.responseMutex.Unlock()
		return nil, fmt.Errorf("LSP request timeout: %s", method)
	}
}
  
// sendRequest sends a JSON-RPC request and expects a response.
func (c *LSPClient) sendRequest(method string, params interface{}) error {
	_, err := c.Request(method, params)
	return err
  
  
  
  
  
  
}
  
// sendNotification sends a JSON-RPC message without expecting a response.

		return err
	}
  
	if c.logCallback != nil {
		msgStr := string(data)
		if len(msgStr) > 500 {
			msgStr = msgStr[:500] + "..."
		}
		c.logCallback("LSP-send", msgStr)
	}
  
	// LSP messages use a header similar to HTTP: Content-Length followed by \r\n\r\n.
	content := fmt.Sprintf("Content-Length: %d\r\n\r\n%s", len(data), data)
  
	c.writeMutex.Lock()
	defer c.writeMutex.Unlock()
	_, err = c.stdin.Write([]byte(content))
	return err
}

				break
			}
  
			lowerLine := strings.ToLower(line)
			var length int
			if strings.HasPrefix(lowerLine, "content-length:") {
				if n, _ := fmt.Sscanf(lowerLine, "content-length: %d", &length); n == 1 {
					contentLength = length
				}
			}
		}
  

			continue
		}
  
		// If the message has an "id", it's either a response to a request we sent
		// or a request from the server to us.
		if idVal, hasID := msg["id"]; hasID {
			method, isServerRequest := msg["method"].(string)
  
			if isServerRequest {
  
  
				if c.logCallback != nil {
					c.logCallback("LSP", fmt.Sprintf("Received server request: %s (ID: %v)", method, idVal))
				}
				// Handle server-to-client requests.
				c.handleServerRequest(method, idVal, msg["params"])
  
  
  
  
  
  
  
  
  
  
  
  
  
			} else {
				if c.logCallback != nil {
					c.logCallback("LSP", fmt.Sprintf("Received response for ID: %v", idVal))
				}
  
				var idInt int64
				validID := false
				switch v := idVal.(type) {
				case float64:
					idInt = int64(v)
					validID = true
				case string:
					fmt.Sscanf(v, "%d", &idInt)
					validID = true
				}
  
				if validID {
					c.responseMutex.Lock()
					ch, exists := c.responses[idInt]
					if exists {
						delete(c.responses, idInt)
						c.responseMutex.Unlock()
						ch <- msg
					} else {
						if c.logCallback != nil {
							c.logCallback("LSP", fmt.Sprintf("No channel found for ID=%d", idInt))
						}
						c.responseMutex.Unlock()
					}
				}
			}
		}
  
		// If it has no "id", it's an asynchronous notification.
		if _, hasID := msg["id"]; !hasID {
			c.handleNotification(msg)
		}
	}
}
  
// handleServerRequest responds to requests initiated by the server.
func (c *LSPClient) handleServerRequest(method string, id interface{}, params interface{}) {
	// For now, we provide minimal responses to keep the server happy.
	var result interface{} = nil
  
	if method == "workspace/configuration" {
		// Return empty settings for any requested scope.
		if p, ok := params.(map[string]interface{}); ok {
			if items, ok := p["items"].([]interface{}); ok {
				res := make([]interface{}, len(items))
				for i := range res {
					res[i] = map[string]interface{}{}
				}
				result = res
			}
		}
	}
  
	response := map[string]interface{}{
		"jsonrpc": "2.0",
		"id":      id,
		"result":  result,
	}
	c.sendMessage(response)
}
  
// handleNotification processes messages initiated by the server.

	}
}
  
// findProjectRoot looks for a project root marker like .git, compile_commands.json, or .clangd.
func findProjectRoot(path string) string {
	dir := filepath.Dir(path)
	for {
		if _, err := os.Stat(filepath.Join(dir, ".git")); err == nil {
			return dir
		}
		if _, err := os.Stat(filepath.Join(dir, "compile_commands.json")); err == nil {
			return dir
		}
		if _, err := os.Stat(filepath.Join(dir, ".clangd")); err == nil {
			return dir
		}
		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
			return dir
		}
  
		parent := filepath.Dir(dir)
		if parent == dir {
			break
		}
		dir = parent
	}
	return filepath.Dir(path)
}
  
// initialize sends the initial 'initialize' request to the server.
func (c *LSPClient) initialize() error {
	rootPath := findProjectRoot(c.filename)
	rootURI := "file://" + rootPath
	params := map[string]interface{}{
		"processId": os.Getpid(),
		"rootUri":   rootURI,
		"rootPath":  rootPath, // Deprecated but some servers still use it.
		"workspaceFolders": []map[string]interface{}{
			{
				"uri":  rootURI,
				"name": filepath.Base(rootPath),
			},
		},
		"capabilities": map[string]interface{}{
			"textDocument": map[string]interface{}{
				"synchronization": map[string]interface{}{
					"didSave":             true,
					"dynamicRegistration": false,
					"willSave":            false,
					"willSaveWaitUntil":   false,
				},
				"publishDiagnostics": map[string]interface{}{},
				"hover": map[string]interface{}{
					"contentFormat": []string{"plaintext"},
				},
				"completion": map[string]interface{}{
					"completionItem": map[string]interface{}{
						"snippetSupport":          false,
						"resolveSupport":          map[string]interface{}{"properties": []string{"documentation", "detail"}},
						"insertReplaceSupport":    true,
						"labelDetailsSupport":     true,
						"deprecatedSupport":       true,
						"commitCharactersSupport": false,
					},
					"contextSupport": true,
				},
				"definition": map[string]interface{}{
					"dynamicRegistration": false,
					"linkSupport":         false,
				},
			},
			"workspace": map[string]interface{}{
				"configuration":    true,
				"workspaceFolders": true,
			},
		},
	}
  
	// Move textDocumentSync to top level of capabilities if needed by some servers,
	// though it's technically under textDocument in some versions.
	// Actually, the spec says it should be under capabilities for server capabilities,
	// but for client capabilities it is under textDocument.
	// However, many servers like gopls prefer it at a certain location.
	// Let's add it to the top level of capabilities as well just in case.
	params["capabilities"].(map[string]interface{})["textDocumentSync"] = 1 // Full
  
	if err := c.sendRequest("initialize", params); err != nil {
		return err
	}

  
// sendDidOpen notifies the server that a file has been opened.
func (c *LSPClient) sendDidOpen(content string) error {
	languageID := c.fileType.LanguageID
	if languageID == "" {
		languageID = strings.ToLower(c.fileType.Name)
	}
	params := map[string]interface{}{
		"textDocument": map[string]interface{}{
			"uri":        c.uri,

  
// Definition requests the location of the definition of the symbol at cursor.
func (c *LSPClient) Definition(line, character int) ([]Location, error) {
  
	params := map[string]interface{}{
		"textDocument": map[string]interface{}{
			"uri": c.uri,

		},
	}
  
	resp, err := c.Request("textDocument/definition", params)
	if err != nil {
  
  
  
  
  
  
  
		return nil, err
	}
  
	result := resp["result"]
	if result == nil {
		return nil, nil
	}
  
  
  
  
  
  
  
  
  
	resJSON, _ := json.Marshal(result)
  
  
  
  
  
	// Definition can return a single Location or an array of them.
	var loc Location
	if err := json.Unmarshal(resJSON, &loc); err == nil && loc.URI != "" {
		return []Location{loc}, nil
	}
  
	var locs []Location
	if err := json.Unmarshal(resJSON, &locs); err == nil {
		return locs, nil
  
  
  
	}
  
	return nil, nil
}
  
// Hover requests documentation information for the symbol at cursor.
func (c *LSPClient) Hover(line, character int) (string, error) {
  
	params := map[string]interface{}{
		"textDocument": map[string]interface{}{
			"uri": c.uri,

		},
	}
  
	resp, err := c.Request("textDocument/hover", params)
	if err != nil {
  
  
  
  
  
  
  
		return "", err
	}
  
	result := resp["result"]
	if result == nil {
		return "", nil
	}
  
  
	// Hover responses are complex: they can be strings, objects, or arrays.
	resMap, ok := result.(map[string]interface{})
	if !ok {
		return "", nil
	}
  
	contents := resMap["contents"]
	if contents == nil {
		return "", nil
	}
  
  
	if mc, ok := contents.(map[string]interface{}); ok {
		if val, ok := mc["value"].(string); ok {
			return stripMarkdown(val), nil
		}
	}
  
	if s, ok := contents.(string); ok {
		return stripMarkdown(s), nil
	}
  
  
  
	if ss, ok := contents.([]interface{}); ok {
		var result strings.Builder
		for i, s := range ss {
			if str, ok := s.(string); ok {
				result.WriteString(stripMarkdown(str))
				if i < len(ss)-1 {
					result.WriteString("\n")
				}
			} else if m, ok := s.(map[string]interface{}); ok {
				if val, ok := m["value"].(string); ok {
					result.WriteString(stripMarkdown(val))
					if i < len(ss)-1 {
						result.WriteString("\n")
					}
  
  
  
  
  
  
  
				}
			}
  
		}
		return strings.TrimSpace(result.String()), nil
	}
  
	return "", nil
}
  
// ResolveCompletion requests additional details for a completion item.
func (c *LSPClient) ResolveCompletion(item CompletionItem) (CompletionItem, error) {
	resp, err := c.Request("completionItem/resolve", item)
	if err != nil {
		return item, err
	}
  
	result := resp["result"]
	if result == nil {
		return item, nil
	}
  
	resJSON, _ := json.Marshal(result)
	var resolvedItem CompletionItem
	if err := json.Unmarshal(resJSON, &resolvedItem); err != nil {
		return item, err
	}
  
	return resolvedItem, nil
}
  
// getDocumentationString extracts a plain string from the Documentation field.
func (c *LSPClient) getDocumentationString(doc interface{}) string {
	if doc == nil {
		return ""
	}
	if s, ok := doc.(string); ok {
		return stripMarkdown(s)
	}
	if m, ok := doc.(map[string]interface{}); ok {
		if val, ok := m["value"].(string); ok {
			return stripMarkdown(val)
		}
	}
	return ""
}
  
// Completion requests a list of completion items for the symbol at cursor.
func (c *LSPClient) Completion(line, character int) ([]CompletionItem, error) {
  
	params := map[string]interface{}{
		"textDocument": map[string]interface{}{
			"uri": c.uri,

			"line":      line,
			"character": character,
		},
		"context": map[string]interface{}{
			"triggerKind": 1, // Invited
		},
  
	}
  
	resp, err := c.Request("textDocument/completion", params)
	if err != nil {
  
  
  
  
  
  
  
		return nil, err
	}
  
	result := resp["result"]
	if result == nil {
		return nil, nil
	}
  
  
  
  
  
	resJSON, _ := json.Marshal(result)
  
  
  
  
	// Completion can return a CompletionList or an array of CompletionItems.
	// Try unmarshaling into array of items first as it's more direct.
	var compItems []CompletionItem
	if err := json.Unmarshal(resJSON, &compItems); err == nil && compItems != nil {
		return compItems, nil
	}
  
	var compList CompletionList
	if err := json.Unmarshal(resJSON, &compList); err == nil {
		return compList.Items, nil
	}
  
  
	return nil, nil
  
  
  
  
  
  
  
  
  
  
  
  
  
  
}
  
// sendRequestWithID helper to send a request with a pre-generated ID.
