xonecas.io
62159
Sy

symb / files

symb / internal / lsp / manager.go

9.4 KB
1package lsp
2
3import (
4	"context"
5	"fmt"
6	"io"
7	"log/slog"
8	"os"
9	"os/exec"
10	"path/filepath"
11	"sync"
12	"time"
13
14	powernapconfig "github.com/charmbracelet/x/powernap/pkg/config"
15	powernap "github.com/charmbracelet/x/powernap/pkg/lsp"
16	"github.com/charmbracelet/x/powernap/pkg/lsp/protocol"
17	"github.com/rs/zerolog/log"
18)
19
20// skipAutoStart lists generic commands that should not be auto-started.
21// These interpreters/runners may trigger package downloads or run wrong binaries.
22var skipAutoStart = map[string]bool{
23	"npx":     true,
24	"node":    true,
25	"python":  true,
26	"python3": true,
27	"java":    true,
28	"ruby":    true,
29	"perl":    true,
30	"dotnet":  true,
31	"bun":     true,
32}
33
34// DiagCallback is called when diagnostics change for a file.
35// absPath is the filesystem path; lines maps 0-indexed line numbers to max severity.
36type DiagCallback func(absPath string, lines map[int]int)
37
38// Manager manages LSP server lifecycles keyed by server name.
39type Manager struct {
40	cfgMgr *powernapconfig.Manager
41
42	mu      sync.Mutex
43	clients map[string]*Client // serverName -> client
44	broken  map[string]bool    // servers that failed to start
45
46	callback DiagCallback
47}
48
49// NewManager creates a manager with powernap's built-in server defaults.
50func NewManager() *Manager {
51	// Silence powernap's slog output — it writes to stderr which the TUI owns.
52	slog.SetDefault(slog.New(slog.NewTextHandler(io.Discard, nil)))
53
54	cm := powernapconfig.NewManager()
55	_ = cm.LoadDefaults()
56	return &Manager{
57		cfgMgr:  cm,
58		clients: make(map[string]*Client),
59		broken:  make(map[string]bool),
60	}
61}
62
63// SetCallback sets the function called when diagnostics change.
64func (m *Manager) SetCallback(cb DiagCallback) {
65	m.mu.Lock()
66	defer m.mu.Unlock()
67	m.callback = cb
68}
69
70// TouchFile ensures the right LSP servers are running for this file and
71// sends didOpen/didChange. Non-blocking — errors are logged, not returned.
72func (m *Manager) TouchFile(ctx context.Context, absPath string) {
73	clients := m.ensureClients(ctx, absPath)
74	for _, c := range clients {
75		if err := c.openFile(ctx, absPath); err != nil {
76			log.Error().Err(err).Str("server", c.serverID).Msg("lsp: touchFile openFile")
77		}
78	}
79}
80
81// NotifyAndWait notifies relevant LSP servers of a file change and waits for
82// diagnostics. Returns aggregated diagnostics across all matching servers.
83func (m *Manager) NotifyAndWait(ctx context.Context, absPath string, timeout time.Duration) []protocol.Diagnostic {
84	clients := m.ensureClients(ctx, absPath)
85	if len(clients) == 0 {
86		return nil
87	}
88
89	var all []protocol.Diagnostic
90	for _, c := range clients {
91		diags, err := c.notifyAndWait(ctx, absPath, timeout)
92		if err != nil {
93			log.Error().Err(err).Str("server", c.serverID).Msg("lsp: notifyAndWait")
94			continue
95		}
96		log.Debug().Str("server", c.serverID).Int("count", len(diags)).Str("file", absPath).Msg("lsp: diagnostics received")
97		all = append(all, diags...)
98	}
99
100	log.Debug().Int("total", len(all)).Str("file", absPath).Msg("lsp: aggregated diagnostics")
101
102	// Fire callback once with aggregated diagnostics from all servers.
103	m.mu.Lock()
104	cb := m.callback
105	m.mu.Unlock()
106	if cb != nil {
107		cb(absPath, diagLineSeverities(all))
108	}
109
110	return all
111}
112
113// StopAll gracefully shuts down all running LSP servers.
114func (m *Manager) StopAll(ctx context.Context) {
115	m.mu.Lock()
116	clients := make([]*Client, 0, len(m.clients))
117	for _, c := range m.clients {
118		clients = append(clients, c)
119	}
120	m.mu.Unlock()
121
122	for _, c := range clients {
123		if err := c.close(ctx); err != nil {
124			log.Error().Err(err).Str("server", c.serverID).Msg("lsp: stopAll")
125		}
126	}
127}
128
129// serverToStart holds info needed to start an LSP server outside the lock.
130type serverToStart struct {
131	name    string
132	cfg     *powernapconfig.ServerConfig
133	root    string
134	cmdPath string
135}
136
137// ensureClients finds or starts LSP servers for the given file.
138func (m *Manager) ensureClients(ctx context.Context, absPath string) []*Client {
139	lang := string(powernap.DetectLanguage(absPath))
140	if lang == "" {
141		log.Debug().Str("file", absPath).Msg("lsp: unknown language, skipping")
142		return nil
143	}
144
145	log.Debug().Str("file", absPath).Str("lang", lang).Msg("lsp: ensureClients")
146
147	servers := m.cfgMgr.GetServers()
148
149	// Phase 1: under lock, collect existing clients and identify servers to start.
150	m.mu.Lock()
151	var result []*Client
152	var pending []serverToStart
153
154	for name, cfg := range servers {
155		if !matchesFileType(cfg, lang) {
156			continue
157		}
158		if m.broken[name] {
159			continue
160		}
161		if c, ok := m.clients[name]; ok {
162			result = append(result, c)
163			continue
164		}
165		if skipAutoStart[cfg.Command] {
166			m.broken[name] = true
167			continue
168		}
169		cmdPath := lookPath(cfg.Command)
170		if cmdPath == "" {
171			m.broken[name] = true
172			continue
173		}
174		root := findRoot(absPath, cfg.RootMarkers)
175		if root == "" {
176			root, _ = os.Getwd()
177		}
178		pending = append(pending, serverToStart{name: name, cfg: cfg, root: root, cmdPath: cmdPath})
179	}
180	m.mu.Unlock()
181
182	// Phase 2: start servers without holding the lock (blocking I/O).
183	for _, s := range pending {
184		c, err := m.startClient(ctx, s.name, s.cfg, s.root, s.cmdPath)
185
186		m.mu.Lock()
187		if err != nil {
188			log.Error().Err(err).Str("server", s.name).Msg("lsp: start failed")
189			m.broken[s.name] = true
190		} else {
191			m.clients[s.name] = c
192			result = append(result, c)
193		}
194		m.mu.Unlock()
195	}
196
197	return result
198}
199
200// startClient spawns and initializes a single LSP server. Must be called with m.mu held.
201func (m *Manager) startClient(ctx context.Context, name string, cfg *powernapconfig.ServerConfig, root, cmdPath string) (*Client, error) {
202	rootURI := string(protocol.URIFromPath(root))
203
204	pcfg := powernap.ClientConfig{
205		Command:     cmdPath,
206		Args:        cfg.Args,
207		RootURI:     rootURI,
208		Environment: cfg.Environment,
209		Settings:    cfg.Settings,
210		InitOptions: cfg.InitOptions,
211		WorkspaceFolders: []protocol.WorkspaceFolder{
212			{URI: rootURI, Name: filepath.Base(root)},
213		},
214	}
215
216	c, err := newClient(name, pcfg)
217	if err != nil {
218		return nil, err
219	}
220
221	initCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
222	defer cancel()
223
224	if err := c.initialize(initCtx); err != nil {
225		_ = c.close(ctx)
226		return nil, fmt.Errorf("initialize: %w", err)
227	}
228
229	log.Info().Str("server", name).Str("root", root).Str("cmd", cmdPath).Msg("lsp: server started")
230	return c, nil
231}
232
233// matchesFileType checks if a server config handles the given language ID.
234func matchesFileType(cfg *powernapconfig.ServerConfig, lang string) bool {
235	for _, ft := range cfg.FileTypes {
236		if ft == lang {
237			return true
238		}
239	}
240	return false
241}
242
243// findRoot walks up from the file looking for any of the root markers.
244func findRoot(absPath string, markers []string) string {
245	dir := filepath.Dir(absPath)
246	for {
247		for _, marker := range markers {
248			matches, _ := filepath.Glob(filepath.Join(dir, marker))
249			if len(matches) > 0 {
250				return dir
251			}
252		}
253		parent := filepath.Dir(dir)
254		if parent == dir {
255			return ""
256		}
257		dir = parent
258	}
259}
260
261// diagLineSeverities converts a diagnostic slice to a line->severity map.
262// Only tracks errors (1) and warnings (2). Lower severity number wins.
263func diagLineSeverities(diags []protocol.Diagnostic) map[int]int {
264	if len(diags) == 0 {
265		return nil
266	}
267	lines := make(map[int]int)
268	for _, d := range diags {
269		sev := int(d.Severity)
270		if sev != SeverityError && sev != SeverityWarning {
271			continue
272		}
273		line := int(d.Range.Start.Line) // 0-indexed
274		if existing, ok := lines[line]; !ok || sev < existing {
275			lines[line] = sev
276		}
277	}
278	return lines
279}
280
281// FormatDiagnostics formats diagnostics as a text block for LLM tool responses.
282// Returns empty string if no errors or warnings.
283func FormatDiagnostics(displayPath string, diags []protocol.Diagnostic) string {
284	if len(diags) == 0 {
285		return ""
286	}
287
288	var buf []byte
289	count := 0
290	for _, d := range diags {
291		sev := int(d.Severity)
292		if sev != SeverityError && sev != SeverityWarning {
293			continue
294		}
295		if count == 0 {
296			buf = append(buf, fmt.Sprintf("\nLSP diagnostics:\n<diagnostics file=%q>\n", displayPath)...)
297		}
298		label := "WARNING"
299		if sev == SeverityError {
300			label = "ERROR"
301		}
302		buf = append(buf, fmt.Sprintf("%s [%d:%d] %s\n",
303			label,
304			d.Range.Start.Line+1, // display as 1-indexed
305			d.Range.Start.Character+1,
306			d.Message,
307		)...)
308		count++
309		if count >= 20 {
310			remaining := 0
311			for _, dd := range diags {
312				if int(dd.Severity) == SeverityError || int(dd.Severity) == SeverityWarning {
313					remaining++
314				}
315			}
316			remaining -= count
317			if remaining > 0 {
318				buf = append(buf, fmt.Sprintf("... and %d more\n", remaining)...)
319			}
320			break
321		}
322	}
323	if count == 0 {
324		return ""
325	}
326	buf = append(buf, "</diagnostics>"...)
327	return string(buf)
328}
329
330// lookPath finds a command binary, checking PATH first, then common
331// language-specific bin directories that may not be in PATH.
332func lookPath(command string) string {
333	if p, err := exec.LookPath(command); err == nil {
334		return p
335	}
336
337	// Extra directories where language toolchains install binaries.
338	home, err := os.UserHomeDir()
339	if err != nil {
340		return ""
341	}
342
343	var extras []string
344
345	// Go: $GOBIN or $GOPATH/bin or ~/go/bin
346	if gobin := os.Getenv("GOBIN"); gobin != "" {
347		extras = append(extras, gobin)
348	}
349	if gopath := os.Getenv("GOPATH"); gopath != "" {
350		extras = append(extras, filepath.Join(gopath, "bin"))
351	}
352	extras = append(extras, filepath.Join(home, "go", "bin"))
353
354	// Rust: ~/.cargo/bin
355	extras = append(extras, filepath.Join(home, ".cargo", "bin"))
356
357	// Local bin
358	extras = append(extras, filepath.Join(home, ".local", "bin"))
359
360	for _, dir := range extras {
361		p := filepath.Join(dir, command)
362		if fi, err := os.Stat(p); err == nil && !fi.IsDir() {
363			return p
364		}
365	}
366	return ""
367}