import { BusEvent } from "@/bus/bus-event" import { Bus } from "@/bus" import * as Log from "@opencode-ai/core/util/log" import * as LSPClient from "./client" import path from "path" import { pathToFileURL, fileURLToPath } from "url" import * as LSPServer from "./server" import { Config } from "@/config/config" import { Process } from "@/util/process" import { spawn as lspspawn } from "./launch" import { Effect, Layer, Context, Schema } from "effect" import { InstanceState } from "@/effect/instance-state" import { containsPath } from "@/project/instance-context" import { NonNegativeInt } from "@opencode-ai/core/schema" import { RuntimeFlags } from "@/effect/runtime-flags" const log = Log.create({ service: "lsp" }) export const Event = { Updated: BusEvent.define("lsp.updated", Schema.Struct({})), } const Position = Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt, }) export const Range = Schema.Struct({ start: Position, end: Position, }).annotate({ identifier: "Range" }) export type Range = typeof Range.Type export const Symbol = Schema.Struct({ name: Schema.String, kind: NonNegativeInt, location: Schema.Struct({ uri: Schema.String, range: Range, }), }).annotate({ identifier: "Symbol" }) export type Symbol = typeof Symbol.Type export const DocumentSymbol = Schema.Struct({ name: Schema.String, detail: Schema.optional(Schema.String), kind: NonNegativeInt, range: Range, selectionRange: Range, }).annotate({ identifier: "DocumentSymbol" }) export type DocumentSymbol = typeof DocumentSymbol.Type export const Status = Schema.Struct({ id: Schema.String, name: Schema.String, root: Schema.String, status: Schema.Literals(["connected", "error"]), }).annotate({ identifier: "LSPStatus" }) export type Status = typeof Status.Type enum SymbolKind { File = 1, Module = 2, Namespace = 3, Package = 4, Class = 5, Method = 6, Property = 7, Field = 8, Constructor = 9, Enum = 10, Interface = 11, Function = 12, Variable = 13, Constant = 14, String = 15, Number = 16, Boolean = 17, Array = 18, Object = 19, Key = 20, Null = 21, EnumMember = 22, Struct = 23, Event = 24, Operator = 25, TypeParameter = 26, } const kinds = [ SymbolKind.Class, SymbolKind.Function, SymbolKind.Method, SymbolKind.Interface, SymbolKind.Variable, SymbolKind.Constant, SymbolKind.Struct, SymbolKind.Enum, ] const filterExperimentalServers = (servers: Record, flags: RuntimeFlags.Info) => { if (flags.experimentalLspTy) { if (servers["pyright"]) { log.info("LSP server pyright is disabled because OPENCODE_EXPERIMENTAL_LSP_TY is enabled") delete servers["pyright"] } } else { if (servers["ty"]) { delete servers["ty"] } } } type LocInput = { file: string; line: number; character: number } interface State { clients: LSPClient.Info[] servers: Record broken: Set spawning: Map> } export interface Interface { readonly init: () => Effect.Effect readonly status: () => Effect.Effect readonly hasClients: (file: string) => Effect.Effect readonly touchFile: (input: string, diagnostics?: "document" | "full") => Effect.Effect readonly diagnostics: () => Effect.Effect> readonly hover: (input: LocInput) => Effect.Effect readonly definition: (input: LocInput) => Effect.Effect readonly references: (input: LocInput) => Effect.Effect readonly implementation: (input: LocInput) => Effect.Effect readonly documentSymbol: (uri: string) => Effect.Effect<(DocumentSymbol | Symbol)[]> readonly workspaceSymbol: (query: string) => Effect.Effect readonly prepareCallHierarchy: (input: LocInput) => Effect.Effect readonly incomingCalls: (input: LocInput) => Effect.Effect readonly outgoingCalls: (input: LocInput) => Effect.Effect } export class Service extends Context.Service()("@opencode/LSP") {} export const layer = Layer.effect( Service, Effect.gen(function* () { const config = yield* Config.Service const flags = yield* RuntimeFlags.Service const state = yield* InstanceState.make( Effect.fn("LSP.state")(function* (ctx) { const cfg = yield* config.get() const servers: Record = {} if (!cfg.lsp) { log.info("all LSPs are disabled") } else { for (const server of Object.values(LSPServer)) { servers[server.id] = server } filterExperimentalServers(servers, flags) if (cfg.lsp !== true) { for (const [name, item] of Object.entries(cfg.lsp)) { const existing = servers[name] if (item.disabled) { log.info(`LSP server ${name} is disabled`) delete servers[name] continue } servers[name] = { ...existing, id: name, root: existing?.root ?? (async (_file, ctx) => ctx.directory), extensions: item.extensions ?? existing?.extensions ?? [], spawn: async (root) => ({ process: lspspawn(item.command[0], item.command.slice(1), { cwd: root, env: { ...process.env, ...item.env }, }), initialization: item.initialization, }), } } } log.info("enabled LSP servers", { serverIds: Object.values(servers) .map((server) => server.id) .join(", "), }) } const s: State = { clients: [], servers, broken: new Set(), spawning: new Map(), } yield* Effect.addFinalizer(() => Effect.promise(async () => { await Promise.all(s.clients.map((client) => client.shutdown())) }), ) return s }), ) const getClients = Effect.fnUntraced(function* (file: string) { const ctx = yield* InstanceState.context if (!containsPath(file, ctx)) return [] as LSPClient.Info[] const s = yield* InstanceState.get(state) return yield* Effect.promise(async () => { const extension = path.parse(file).ext || file const result: LSPClient.Info[] = [] async function schedule(server: LSPServer.Info, root: string, key: string) { const handle = await server .spawn(root, ctx, flags) .then((value) => { if (!value) s.broken.add(key) return value }) .catch((err) => { s.broken.add(key) log.error(`Failed to spawn LSP server ${server.id}`, { error: err }) return undefined }) if (!handle) return undefined log.info("spawned lsp server", { serverID: server.id, root }) const client = await LSPClient.create({ serverID: server.id, server: handle, root, directory: ctx.directory, instance: ctx, }).catch(async (err) => { s.broken.add(key) await Process.stop(handle.process) log.error(`Failed to initialize LSP client ${server.id}`, { error: err }) return undefined }) if (!client) return undefined const existing = s.clients.find((x) => x.root === root && x.serverID === server.id) if (existing) { await Process.stop(handle.process) return existing } s.clients.push(client) return client } for (const server of Object.values(s.servers)) { if (server.extensions.length && !server.extensions.includes(extension)) continue const root = await server.root(file, ctx) if (!root) continue if (s.broken.has(root + server.id)) continue const match = s.clients.find((x) => x.root === root && x.serverID === server.id) if (match) { result.push(match) continue } const inflight = s.spawning.get(root + server.id) if (inflight) { const client = await inflight if (!client) continue result.push(client) continue } const task = schedule(server, root, root + server.id) s.spawning.set(root + server.id, task) task.finally(() => { if (s.spawning.get(root + server.id) === task) { s.spawning.delete(root + server.id) } }) const client = await task if (!client) continue result.push(client) await Bus.publish(ctx, Event.Updated, {}) } return result }) }) const run = Effect.fnUntraced(function* (file: string, fn: (client: LSPClient.Info) => Promise) { const clients = yield* getClients(file) return yield* Effect.promise(() => Promise.all(clients.map((x) => fn(x)))) }) const runAll = Effect.fnUntraced(function* (fn: (client: LSPClient.Info) => Promise) { const s = yield* InstanceState.get(state) return yield* Effect.promise(() => Promise.all(s.clients.map((x) => fn(x)))) }) const init = Effect.fn("LSP.init")(function* () { yield* InstanceState.get(state) }) const status = Effect.fn("LSP.status")(function* () { const ctx = yield* InstanceState.context const s = yield* InstanceState.get(state) const result: Status[] = [] for (const client of s.clients) { result.push({ id: client.serverID, name: s.servers[client.serverID].id, root: path.relative(ctx.directory, client.root), status: "connected", }) } return result }) const hasClients = Effect.fn("LSP.hasClients")(function* (file: string) { const ctx = yield* InstanceState.context const s = yield* InstanceState.get(state) return yield* Effect.promise(async () => { const extension = path.parse(file).ext || file for (const server of Object.values(s.servers)) { if (server.extensions.length && !server.extensions.includes(extension)) continue const root = await server.root(file, ctx) if (!root) continue if (s.broken.has(root + server.id)) continue return true } return false }) }) const touchFile = Effect.fn("LSP.touchFile")(function* (input: string, diagnostics?: "document" | "full") { log.info("touching file", { file: input }) const clients = yield* getClients(input) yield* Effect.promise(() => Promise.all( clients.map(async (client) => { const after = Date.now() const version = await client.notify.open({ path: input }) if (!diagnostics) return return client.waitForDiagnostics({ path: input, version, mode: diagnostics, after, }) }), ).catch((err) => { log.error("failed to touch file", { err, file: input }) }), ) }) const diagnostics = Effect.fn("LSP.diagnostics")(function* () { const results: Record = {} const all = yield* runAll(async (client) => client.diagnostics) for (const result of all) { for (const [p, diags] of result.entries()) { const arr = results[p] || [] arr.push(...diags) results[p] = arr } } return results }) const hover = Effect.fn("LSP.hover")(function* (input: LocInput) { return yield* run(input.file, (client) => client.connection .sendRequest("textDocument/hover", { textDocument: { uri: pathToFileURL(input.file).href }, position: { line: input.line, character: input.character }, }) .catch(() => null), ) }) const definition = Effect.fn("LSP.definition")(function* (input: LocInput) { const results = yield* run(input.file, (client) => client.connection .sendRequest("textDocument/definition", { textDocument: { uri: pathToFileURL(input.file).href }, position: { line: input.line, character: input.character }, }) .catch(() => null), ) return results.flat().filter(Boolean) }) const references = Effect.fn("LSP.references")(function* (input: LocInput) { const results = yield* run(input.file, (client) => client.connection .sendRequest("textDocument/references", { textDocument: { uri: pathToFileURL(input.file).href }, position: { line: input.line, character: input.character }, context: { includeDeclaration: true }, }) .catch(() => []), ) return results.flat().filter(Boolean) }) const implementation = Effect.fn("LSP.implementation")(function* (input: LocInput) { const results = yield* run(input.file, (client) => client.connection .sendRequest("textDocument/implementation", { textDocument: { uri: pathToFileURL(input.file).href }, position: { line: input.line, character: input.character }, }) .catch(() => null), ) return results.flat().filter(Boolean) }) const documentSymbol = Effect.fn("LSP.documentSymbol")(function* (uri: string) { const file = fileURLToPath(uri) const results = yield* run(file, (client) => client.connection.sendRequest("textDocument/documentSymbol", { textDocument: { uri } }).catch(() => []), ) return (results.flat() as (DocumentSymbol | Symbol)[]).filter(Boolean) }) const workspaceSymbol = Effect.fn("LSP.workspaceSymbol")(function* (query: string) { const results = yield* runAll((client) => client.connection .sendRequest("workspace/symbol", { query }) .then((result) => result.filter((x) => kinds.includes(x.kind)).slice(0, 10)) .catch(() => [] as Symbol[]), ) return results.flat() }) const prepareCallHierarchy = Effect.fn("LSP.prepareCallHierarchy")(function* (input: LocInput) { const results = yield* run(input.file, (client) => client.connection .sendRequest("textDocument/prepareCallHierarchy", { textDocument: { uri: pathToFileURL(input.file).href }, position: { line: input.line, character: input.character }, }) .catch(() => []), ) return results.flat().filter(Boolean) }) const callHierarchyRequest = Effect.fnUntraced(function* ( input: LocInput, direction: "callHierarchy/incomingCalls" | "callHierarchy/outgoingCalls", ) { const results = yield* run(input.file, async (client) => { const items = await client.connection .sendRequest("textDocument/prepareCallHierarchy", { textDocument: { uri: pathToFileURL(input.file).href }, position: { line: input.line, character: input.character }, }) .catch(() => [] as unknown[]) if (!items?.length) return [] return client.connection.sendRequest(direction, { item: items[0] }).catch(() => []) }) return results.flat().filter(Boolean) }) const incomingCalls = Effect.fn("LSP.incomingCalls")(function* (input: LocInput) { return yield* callHierarchyRequest(input, "callHierarchy/incomingCalls") }) const outgoingCalls = Effect.fn("LSP.outgoingCalls")(function* (input: LocInput) { return yield* callHierarchyRequest(input, "callHierarchy/outgoingCalls") }) return Service.of({ init, status, hasClients, touchFile, diagnostics, hover, definition, references, implementation, documentSymbol, workspaceSymbol, prepareCallHierarchy, incomingCalls, outgoingCalls, }) }), ) export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(RuntimeFlags.defaultLayer)) export * as Diagnostic from "./diagnostic" export * as LSP from "./lsp"