lsp

type Client interface {
	Initializer
	DiagnosticsProvider
	NavigationProvider
	HoverProvider
	SymbolsProvider
}

type Conn interface {
	// Call sends a JSON-RPC request and unmarshals the response result into result.
	// result must be a pointer to the expected response type, or nil.
	Call(ctx context.Context, method string, params any, result any) error

	// Notify sends a JSON-RPC notification (no response expected).
	Notify(ctx context.Context, method string, params any) error

	// Close closes the connection and releases resources.
	Close() error
}

type Diagnostic struct {
	// Range is the range at which the message applies.
	Range Range `json:"range"`

	// Severity is the diagnostic's severity level.
	Severity DiagnosticSeverity `json:"severity"`

	// Code is the diagnostic's code (e.g., "E0001"). May be empty.
	Code string `json:"code,omitempty"`

	// Source identifies the tool that produced this diagnostic (e.g., "gopls").
	Source string `json:"source,omitempty"`

	// Message is the diagnostic's human-readable message.
	Message string `json:"message"`
}

type DiagnosticSeverity int

type DiagnosticsProvider interface {
	// Diagnostics retrieves diagnostics for the given document URI.
	Diagnostics(ctx context.Context, uri string) ([]Diagnostic, error)
}

type DocumentSymbol struct {
	// Name is the symbol's name.
	Name string `json:"name"`

	// Kind is the symbol's kind (function, class, variable, etc.).
	Kind SymbolKind `json:"kind"`

	// Range is the range enclosing this symbol, not including leading/trailing whitespace.
	Range Range `json:"range"`

	// Children contains child symbols (e.g., struct fields, class methods).
	Children []DocumentSymbol `json:"children,omitempty"`
}

type HoverProvider interface {
	// Hover returns hover information for the symbol at the given position.
	Hover(ctx context.Context, uri string, pos Position) (*HoverResult, error)
}

type HoverResult struct {
	// Contents is the hover information content (may be markdown).
	Contents string `json:"contents"`

	// Range is the optional range for the symbol being hovered.
	Range *Range `json:"range,omitempty"`
}

type InitializeResult struct {
	// Capabilities describes the server's capabilities.
	Capabilities json.RawMessage `json:"capabilities"`
}

type Initializer interface {
	// Initialize sends the LSP initialize request and initialized notification.
	Initialize(ctx context.Context, rootURI string) error

	// Shutdown sends the LSP shutdown request followed by an exit notification.
	Shutdown(ctx context.Context) error
}

type JSONRPCError struct {
	// Code is the error code.
	Code int `json:"code"`

	// Message is a short description of the error.
	Message string `json:"message"`

	// Data contains additional information about the error.
	Data json.RawMessage `json:"data,omitempty"`
}

type Location struct {
	// URI is the resource identifier (e.g., "file:///path/to/file.go").
	URI string `json:"uri"`

	// Range is the range within the resource.
	Range Range `json:"range"`
}

type ManagerOption func(*serverManager)

type MessageTransport interface {
	// ReadMessage reads a complete LSP message and returns the JSON body.
	ReadMessage(ctx context.Context) (json.RawMessage, error)

	// WriteMessage writes a JSON body as a complete LSP message with headers.
	WriteMessage(ctx context.Context, data json.RawMessage) error

	// Close closes the transport connection.
	Close() error
}

type NavigationProvider interface {
	// References returns all reference locations for the symbol at the given position.
	References(ctx context.Context, uri string, pos Position) ([]Location, error)

	// Definition returns the definition location(s) for the symbol at the given position.
	Definition(ctx context.Context, uri string, pos Position) ([]Location, error)
}

type Position struct {
	// Line is the zero-based line number.
	Line int `json:"line"`

	// Character is the zero-based character offset on the line.
	Character int `json:"character"`
}

type ProcessHandle interface {
	// Kill forcefully terminates the server process.
	Kill() error

	// Wait blocks until the server process exits.
	Wait() error

	// IsRunning reports whether the server process is still running.
	IsRunning() bool
}

type Range struct {
	// Start is the range's start position (inclusive).
	Start Position `json:"start"`

	// End is the range's end position (exclusive).
	End Position `json:"end"`
}

type ServerLauncher interface {
	// Launch starts a language server for the given language and returns
	// the initialized client and a handle to the server process.
	Launch(ctx context.Context, lang string) (Client, ProcessHandle, error)
}

type ServerManager interface {
	// StartServer starts a language server for the given language.
	// Returns nil if the server is already running (idempotent).
	StartServer(ctx context.Context, lang string) error

	// StopServer stops the language server for the given language.
	// Returns nil if the server is not running (idempotent).
	StopServer(ctx context.Context, lang string) error

	// GetClient returns the LSP client for the given language.
	// Returns ErrServerNotRunning if the server is not running.
	GetClient(lang string) (Client, error)

	// ActiveServers returns a sorted list of languages with running servers.
	ActiveServers() []string

	// HealthCheck checks the health of all active servers.
	// Returns a map from language to error (nil means healthy).
	HealthCheck(ctx context.Context) map[string]error

	// StartAll starts servers for all given languages concurrently.
	// Individual failures are non-fatal (graceful degradation).
	StartAll(ctx context.Context, langs []string) error

	// StopAll stops all running servers.
	StopAll(ctx context.Context) error

	// CollectAllDiagnostics collects diagnostics from all active servers concurrently.
	// Individual server errors are non-fatal.
	CollectAllDiagnostics(ctx context.Context, uri string) ([]Diagnostic, error)
}

type StreamTransport struct {
	// contains filtered or unexported fields
}

type SymbolKind int

type SymbolsProvider interface {
	// Symbols returns the document symbols for the given document URI.
	Symbols(ctx context.Context, uri string) ([]DocumentSymbol, error)
}