feat: unwrap lsp namespaces to flat exports + barrel (#22748)

packages/opencode/src/config/config.ts

@@ -19,7 +19,7 @@ import {
   printParseErrorCode,
 } from "jsonc-parser"
 import { Instance, type InstanceContext } from "../project/instance"
-import { LSPServer } from "../lsp/server"
+import { LSPServer } from "../lsp"
 import { Installation } from "@/installation"
 import { ConfigMarkdown } from "."
 import { existsSync } from "fs"

packages/opencode/src/lsp/client.ts

@@ -8,7 +8,7 @@ import { Log } from "../util"
 import { Process } from "../util"
 import { LANGUAGE_EXTENSIONS } from "./language"
 import z from "zod"
-import type { LSPServer } from "./server"
+import type { LSPServer } from "."
 import { NamedError } from "@opencode-ai/shared/util/error"
 import { withTimeout } from "../util/timeout"
 import { Instance } from "../project/instance"
@@ -16,237 +16,235 @@ import { Filesystem } from "../util"
 
 const DIAGNOSTICS_DEBOUNCE_MS = 150
 
-export namespace LSPClient {
+const log = Log.create({ service: "lsp.client" })
-  const log = Log.create({ service: "lsp.client" })
 
-  export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
+export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
 
-  export type Diagnostic = VSCodeDiagnostic
+export type Diagnostic = VSCodeDiagnostic
 
-  export const InitializeError = NamedError.create(
+export const InitializeError = NamedError.create(
-    "LSPInitializeError",
+  "LSPInitializeError",
+  z.object({
+    serverID: z.string(),
+  }),
+)
+
+export const Event = {
+  Diagnostics: BusEvent.define(
+    "lsp.client.diagnostics",
     z.object({
       serverID: z.string(),
+      path: z.string(),
     }),
+  ),
+}
+
+export async function create(input: { serverID: string; server: LSPServer.Handle; root: string }) {
+  const l = log.clone().tag("serverID", input.serverID)
+  l.info("starting client")
+
+  const connection = createMessageConnection(
+    new StreamMessageReader(input.server.process.stdout as any),
+    new StreamMessageWriter(input.server.process.stdin as any),
   )
 
-  export const Event = {
+  const diagnostics = new Map<string, Diagnostic[]>()
-    Diagnostics: BusEvent.define(
+  connection.onNotification("textDocument/publishDiagnostics", (params) => {
-      "lsp.client.diagnostics",
+    const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
-      z.object({
+    l.info("textDocument/publishDiagnostics", {
-        serverID: z.string(),
+      path: filePath,
-        path: z.string(),
+      count: params.diagnostics.length,
-      }),
+    })
-    ),
+    const exists = diagnostics.has(filePath)
+    diagnostics.set(filePath, params.diagnostics)
+    if (!exists && input.serverID === "typescript") return
+    Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+  })
+  connection.onRequest("window/workDoneProgress/create", (params) => {
+    l.info("window/workDoneProgress/create", params)
+    return null
+  })
+  connection.onRequest("workspace/configuration", async () => {
+    // Return server initialization options
+    return [input.server.initialization ?? {}]
+  })
+  connection.onRequest("client/registerCapability", async () => {})
+  connection.onRequest("client/unregisterCapability", async () => {})
+  connection.onRequest("workspace/workspaceFolders", async () => [
+    {
+      name: "workspace",
+      uri: pathToFileURL(input.root).href,
+    },
+  ])
+  connection.listen()
+
+  l.info("sending initialize")
+  await withTimeout(
+    connection.sendRequest("initialize", {
+      rootUri: pathToFileURL(input.root).href,
+      processId: input.server.process.pid,
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: pathToFileURL(input.root).href,
+        },
+      ],
+      initializationOptions: {
+        ...input.server.initialization,
+      },
+      capabilities: {
+        window: {
+          workDoneProgress: true,
+        },
+        workspace: {
+          configuration: true,
+          didChangeWatchedFiles: {
+            dynamicRegistration: true,
+          },
+        },
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+          },
+          publishDiagnostics: {
+            versionSupport: true,
+          },
+        },
+      },
+    }),
+    45_000,
+  ).catch((err) => {
+    l.error("initialize error", { error: err })
+    throw new InitializeError(
+      { serverID: input.serverID },
+      {
+        cause: err,
+      },
+    )
+  })
+
+  await connection.sendNotification("initialized", {})
+
+  if (input.server.initialization) {
+    await connection.sendNotification("workspace/didChangeConfiguration", {
+      settings: input.server.initialization,
+    })
   }
 
-  export async function create(input: { serverID: string; server: LSPServer.Handle; root: string }) {
+  const files: {
-    const l = log.clone().tag("serverID", input.serverID)
+    [path: string]: number
-    l.info("starting client")
+  } = {}
 
-    const connection = createMessageConnection(
+  const result = {
-      new StreamMessageReader(input.server.process.stdout as any),
+    root: input.root,
-      new StreamMessageWriter(input.server.process.stdin as any),
+    get serverID() {
-    )
+      return input.serverID
-
+    },
-    const diagnostics = new Map<string, Diagnostic[]>()
+    get connection() {
-    connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      return connection
-      const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
+    },
-      l.info("textDocument/publishDiagnostics", {
+    notify: {
-        path: filePath,
+      async open(input: { path: string }) {
-        count: params.diagnostics.length,
+        input.path = path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path)
-      })
+        const text = await Filesystem.readText(input.path)
-      const exists = diagnostics.has(filePath)
+        const extension = path.extname(input.path)
-      diagnostics.set(filePath, params.diagnostics)
+        const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
-      if (!exists && input.serverID === "typescript") return
-      void Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
-    })
-    connection.onRequest("window/workDoneProgress/create", (params) => {
-      l.info("window/workDoneProgress/create", params)
-      return null
-    })
-    connection.onRequest("workspace/configuration", async () => {
-      // Return server initialization options
-      return [input.server.initialization ?? {}]
-    })
-    connection.onRequest("client/registerCapability", async () => {})
-    connection.onRequest("client/unregisterCapability", async () => {})
-    connection.onRequest("workspace/workspaceFolders", async () => [
-      {
-        name: "workspace",
-        uri: pathToFileURL(input.root).href,
-      },
-    ])
-    connection.listen()
-
-    l.info("sending initialize")
-    await withTimeout(
-      connection.sendRequest("initialize", {
-        rootUri: pathToFileURL(input.root).href,
-        processId: input.server.process.pid,
-        workspaceFolders: [
-          {
-            name: "workspace",
-            uri: pathToFileURL(input.root).href,
-          },
-        ],
-        initializationOptions: {
-          ...input.server.initialization,
-        },
-        capabilities: {
-          window: {
-            workDoneProgress: true,
-          },
-          workspace: {
-            configuration: true,
-            didChangeWatchedFiles: {
-              dynamicRegistration: true,
-            },
-          },
-          textDocument: {
-            synchronization: {
-              didOpen: true,
-              didChange: true,
-            },
-            publishDiagnostics: {
-              versionSupport: true,
-            },
-          },
-        },
-      }),
-      45_000,
-    ).catch((err) => {
-      l.error("initialize error", { error: err })
-      throw new InitializeError(
-        { serverID: input.serverID },
-        {
-          cause: err,
-        },
-      )
-    })
-
-    await connection.sendNotification("initialized", {})
-
-    if (input.server.initialization) {
-      await connection.sendNotification("workspace/didChangeConfiguration", {
-        settings: input.server.initialization,
-      })
-    }
-
-    const files: {
-      [path: string]: number
-    } = {}
-
-    const result = {
-      root: input.root,
-      get serverID() {
-        return input.serverID
-      },
-      get connection() {
-        return connection
-      },
-      notify: {
-        async open(input: { path: string }) {
-          input.path = path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path)
-          const text = await Filesystem.readText(input.path)
-          const extension = path.extname(input.path)
-          const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
-
-          const version = files[input.path]
-          if (version !== undefined) {
-            log.info("workspace/didChangeWatchedFiles", input)
-            await connection.sendNotification("workspace/didChangeWatchedFiles", {
-              changes: [
-                {
-                  uri: pathToFileURL(input.path).href,
-                  type: 2, // Changed
-                },
-              ],
-            })
-
-            const next = version + 1
-            files[input.path] = next
-            log.info("textDocument/didChange", {
-              path: input.path,
-              version: next,
-            })
-            await connection.sendNotification("textDocument/didChange", {
-              textDocument: {
-                uri: pathToFileURL(input.path).href,
-                version: next,
-              },
-              contentChanges: [{ text }],
-            })
-            return
-          }
 
+        const version = files[input.path]
+        if (version !== undefined) {
           log.info("workspace/didChangeWatchedFiles", input)
           await connection.sendNotification("workspace/didChangeWatchedFiles", {
             changes: [
               {
                 uri: pathToFileURL(input.path).href,
-                type: 1, // Created
+                type: 2, // Changed
               },
             ],
           })
 
-          log.info("textDocument/didOpen", input)
+          const next = version + 1
-          diagnostics.delete(input.path)
+          files[input.path] = next
-          await connection.sendNotification("textDocument/didOpen", {
+          log.info("textDocument/didChange", {
+            path: input.path,
+            version: next,
+          })
+          await connection.sendNotification("textDocument/didChange", {
             textDocument: {
               uri: pathToFileURL(input.path).href,
-              languageId,
+              version: next,
-              version: 0,
-              text,
             },
+            contentChanges: [{ text }],
           })
-          files[input.path] = 0
           return
-        },
+        }
+
+        log.info("workspace/didChangeWatchedFiles", input)
+        await connection.sendNotification("workspace/didChangeWatchedFiles", {
+          changes: [
+            {
+              uri: pathToFileURL(input.path).href,
+              type: 1, // Created
+            },
+          ],
+        })
+
+        log.info("textDocument/didOpen", input)
+        diagnostics.delete(input.path)
+        await connection.sendNotification("textDocument/didOpen", {
+          textDocument: {
+            uri: pathToFileURL(input.path).href,
+            languageId,
+            version: 0,
+            text,
+          },
+        })
+        files[input.path] = 0
+        return
       },
-      get diagnostics() {
+    },
-        return diagnostics
+    get diagnostics() {
-      },
+      return diagnostics
-      async waitForDiagnostics(input: { path: string }) {
+    },
-        const normalizedPath = Filesystem.normalizePath(
+    async waitForDiagnostics(input: { path: string }) {
-          path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path),
+      const normalizedPath = Filesystem.normalizePath(
-        )
+        path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path),
-        log.info("waiting for diagnostics", { path: normalizedPath })
+      )
-        let unsub: () => void
+      log.info("waiting for diagnostics", { path: normalizedPath })
-        let debounceTimer: ReturnType<typeof setTimeout> | undefined
+      let unsub: () => void
-        return await withTimeout(
+      let debounceTimer: ReturnType<typeof setTimeout> | undefined
-          new Promise<void>((resolve) => {
+      return await withTimeout(
-            unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+        new Promise<void>((resolve) => {
-              if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
+          unsub = Bus.subscribe(Event.Diagnostics, (event) => {
-                // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
+            if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
-                if (debounceTimer) clearTimeout(debounceTimer)
+              // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
-                debounceTimer = setTimeout(() => {
+              if (debounceTimer) clearTimeout(debounceTimer)
-                  log.info("got diagnostics", { path: normalizedPath })
+              debounceTimer = setTimeout(() => {
-                  unsub?.()
+                log.info("got diagnostics", { path: normalizedPath })
-                  resolve()
+                unsub?.()
-                }, DIAGNOSTICS_DEBOUNCE_MS)
+                resolve()
-              }
+              }, DIAGNOSTICS_DEBOUNCE_MS)
-            })
+            }
-          }),
-          3000,
-        )
-          .catch(() => {})
-          .finally(() => {
-            if (debounceTimer) clearTimeout(debounceTimer)
-            unsub?.()
           })
-      },
+        }),
-      async shutdown() {
+        3000,
-        l.info("shutting down")
+      )
-        connection.end()
+        .catch(() => {})
-        connection.dispose()
+        .finally(() => {
-        await Process.stop(input.server.process)
+          if (debounceTimer) clearTimeout(debounceTimer)
-        l.info("shutdown")
+          unsub?.()
-      },
+        })
-    }
+    },
-
+    async shutdown() {
-    l.info("initialized")
+      l.info("shutting down")
-
+      connection.end()
-    return result
+      connection.dispose()
+      await Process.stop(input.server.process)
+      l.info("shutdown")
+    },
   }
+
+  l.info("initialized")
+
+  return result
 }

packages/opencode/src/lsp/index.ts

@@ -1,537 +1,3 @@
-import { BusEvent } from "@/bus/bus-event"
+export * as LSP from "./lsp"
-import { Bus } from "@/bus"
+export * as LSPClient from "./client"
-import { Log } from "../util"
+export * as LSPServer from "./server"
-import { LSPClient } from "./client"
-import path from "path"
-import { pathToFileURL, fileURLToPath } from "url"
-import { LSPServer } from "./server"
-import z from "zod"
-import { Config } from "../config"
-import { Instance } from "../project/instance"
-import { Flag } from "@/flag/flag"
-import { Process } from "../util"
-import { spawn as lspspawn } from "./launch"
-import { Effect, Layer, Context } from "effect"
-import { InstanceState } from "@/effect"
-
-export namespace LSP {
-  const log = Log.create({ service: "lsp" })
-
-  export const Event = {
-    Updated: BusEvent.define("lsp.updated", z.object({})),
-  }
-
-  export const Range = z
-    .object({
-      start: z.object({
-        line: z.number(),
-        character: z.number(),
-      }),
-      end: z.object({
-        line: z.number(),
-        character: z.number(),
-      }),
-    })
-    .meta({
-      ref: "Range",
-    })
-  export type Range = z.infer<typeof Range>
-
-  export const Symbol = z
-    .object({
-      name: z.string(),
-      kind: z.number(),
-      location: z.object({
-        uri: z.string(),
-        range: Range,
-      }),
-    })
-    .meta({
-      ref: "Symbol",
-    })
-  export type Symbol = z.infer<typeof Symbol>
-
-  export const DocumentSymbol = z
-    .object({
-      name: z.string(),
-      detail: z.string().optional(),
-      kind: z.number(),
-      range: Range,
-      selectionRange: Range,
-    })
-    .meta({
-      ref: "DocumentSymbol",
-    })
-  export type DocumentSymbol = z.infer<typeof DocumentSymbol>
-
-  export const Status = z
-    .object({
-      id: z.string(),
-      name: z.string(),
-      root: z.string(),
-      status: z.union([z.literal("connected"), z.literal("error")]),
-    })
-    .meta({
-      ref: "LSPStatus",
-    })
-  export type Status = z.infer<typeof Status>
-
-  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<string, LSPServer.Info>) => {
-    if (Flag.OPENCODE_EXPERIMENTAL_LSP_TY) {
-      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<string, LSPServer.Info>
-    broken: Set<string>
-    spawning: Map<string, Promise<LSPClient.Info | undefined>>
-  }
-
-  export interface Interface {
-    readonly init: () => Effect.Effect<void>
-    readonly status: () => Effect.Effect<Status[]>
-    readonly hasClients: (file: string) => Effect.Effect<boolean>
-    readonly touchFile: (input: string, waitForDiagnostics?: boolean) => Effect.Effect<void>
-    readonly diagnostics: () => Effect.Effect<Record<string, LSPClient.Diagnostic[]>>
-    readonly hover: (input: LocInput) => Effect.Effect<any>
-    readonly definition: (input: LocInput) => Effect.Effect<any[]>
-    readonly references: (input: LocInput) => Effect.Effect<any[]>
-    readonly implementation: (input: LocInput) => Effect.Effect<any[]>
-    readonly documentSymbol: (uri: string) => Effect.Effect<(LSP.DocumentSymbol | LSP.Symbol)[]>
-    readonly workspaceSymbol: (query: string) => Effect.Effect<LSP.Symbol[]>
-    readonly prepareCallHierarchy: (input: LocInput) => Effect.Effect<any[]>
-    readonly incomingCalls: (input: LocInput) => Effect.Effect<any[]>
-    readonly outgoingCalls: (input: LocInput) => Effect.Effect<any[]>
-  }
-
-  export class Service extends Context.Service<Service, Interface>()("@opencode/LSP") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-
-      const state = yield* InstanceState.make<State>(
-        Effect.fn("LSP.state")(function* () {
-          const cfg = yield* config.get()
-
-          const servers: Record<string, LSPServer.Info> = {}
-
-          if (cfg.lsp === false) {
-            log.info("all LSPs are disabled")
-          } else {
-            for (const server of Object.values(LSPServer)) {
-              servers[server.id] = server
-            }
-
-            filterExperimentalServers(servers)
-
-            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 () => Instance.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) {
-        if (!Instance.containsPath(file)) 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)
-              .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,
-            }).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)
-            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)
-
-            void 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)
-            void Bus.publish(Event.Updated, {})
-          }
-
-          return result
-        })
-      })
-
-      const run = Effect.fnUntraced(function* <T>(file: string, fn: (client: LSPClient.Info) => Promise<T>) {
-        const clients = yield* getClients(file)
-        return yield* Effect.promise(() => Promise.all(clients.map((x) => fn(x))))
-      })
-
-      const runAll = Effect.fnUntraced(function* <T>(fn: (client: LSPClient.Info) => Promise<T>) {
-        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 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(Instance.directory, client.root),
-            status: "connected",
-          })
-        }
-        return result
-      })
-
-      const hasClients = Effect.fn("LSP.hasClients")(function* (file: string) {
-        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)
-            if (!root) continue
-            if (s.broken.has(root + server.id)) continue
-            return true
-          }
-          return false
-        })
-      })
-
-      const touchFile = Effect.fn("LSP.touchFile")(function* (input: string, waitForDiagnostics?: boolean) {
-        log.info("touching file", { file: input })
-        const clients = yield* getClients(input)
-        yield* Effect.promise(() =>
-          Promise.all(
-            clients.map(async (client) => {
-              const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
-              await client.notify.open({ path: input })
-              return wait
-            }),
-          ).catch((err) => {
-            log.error("failed to touch file", { err, file: input })
-          }),
-        )
-      })
-
-      const diagnostics = Effect.fn("LSP.diagnostics")(function* () {
-        const results: Record<string, LSPClient.Diagnostic[]> = {}
-        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 (LSP.DocumentSymbol | LSP.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: any) => result.filter((x: LSP.Symbol) => kinds.includes(x.kind)))
-            .then((result: any) => result.slice(0, 10))
-            .catch(() => []),
-        )
-        return results.flat() as LSP.Symbol[]
-      })
-
-      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 any[]
-          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))
-
-  export namespace Diagnostic {
-    const MAX_PER_FILE = 20
-
-    export function pretty(diagnostic: LSPClient.Diagnostic) {
-      const severityMap = {
-        1: "ERROR",
-        2: "WARN",
-        3: "INFO",
-        4: "HINT",
-      }
-
-      const severity = severityMap[diagnostic.severity || 1]
-      const line = diagnostic.range.start.line + 1
-      const col = diagnostic.range.start.character + 1
-
-      return `${severity} [${line}:${col}] ${diagnostic.message}`
-    }
-
-    export function report(file: string, issues: LSPClient.Diagnostic[]) {
-      const errors = issues.filter((item) => item.severity === 1)
-      if (errors.length === 0) return ""
-      const limited = errors.slice(0, MAX_PER_FILE)
-      const more = errors.length - MAX_PER_FILE
-      const suffix = more > 0 ? `\n... and ${more} more` : ""
-      return `<diagnostics file="${file}">\n${limited.map(pretty).join("\n")}${suffix}\n</diagnostics>`
-    }
-  }
-}

packages/opencode/src/lsp/lsp.ts

@@ -0,0 +1,535 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { Log } from "../util"
+import { LSPClient } from "."
+import path from "path"
+import { pathToFileURL, fileURLToPath } from "url"
+import { LSPServer } from "."
+import z from "zod"
+import { Config } from "../config"
+import { Instance } from "../project/instance"
+import { Flag } from "@/flag/flag"
+import { Process } from "../util"
+import { spawn as lspspawn } from "./launch"
+import { Effect, Layer, Context } from "effect"
+import { InstanceState } from "@/effect"
+
+const log = Log.create({ service: "lsp" })
+
+export const Event = {
+  Updated: BusEvent.define("lsp.updated", z.object({})),
+}
+
+export const Range = z
+  .object({
+    start: z.object({
+      line: z.number(),
+      character: z.number(),
+    }),
+    end: z.object({
+      line: z.number(),
+      character: z.number(),
+    }),
+  })
+  .meta({
+    ref: "Range",
+  })
+export type Range = z.infer<typeof Range>
+
+export const Symbol = z
+  .object({
+    name: z.string(),
+    kind: z.number(),
+    location: z.object({
+      uri: z.string(),
+      range: Range,
+    }),
+  })
+  .meta({
+    ref: "Symbol",
+  })
+export type Symbol = z.infer<typeof Symbol>
+
+export const DocumentSymbol = z
+  .object({
+    name: z.string(),
+    detail: z.string().optional(),
+    kind: z.number(),
+    range: Range,
+    selectionRange: Range,
+  })
+  .meta({
+    ref: "DocumentSymbol",
+  })
+export type DocumentSymbol = z.infer<typeof DocumentSymbol>
+
+export const Status = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    root: z.string(),
+    status: z.union([z.literal("connected"), z.literal("error")]),
+  })
+  .meta({
+    ref: "LSPStatus",
+  })
+export type Status = z.infer<typeof Status>
+
+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<string, LSPServer.Info>) => {
+  if (Flag.OPENCODE_EXPERIMENTAL_LSP_TY) {
+    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<string, LSPServer.Info>
+  broken: Set<string>
+  spawning: Map<string, Promise<LSPClient.Info | undefined>>
+}
+
+export interface Interface {
+  readonly init: () => Effect.Effect<void>
+  readonly status: () => Effect.Effect<Status[]>
+  readonly hasClients: (file: string) => Effect.Effect<boolean>
+  readonly touchFile: (input: string, waitForDiagnostics?: boolean) => Effect.Effect<void>
+  readonly diagnostics: () => Effect.Effect<Record<string, LSPClient.Diagnostic[]>>
+  readonly hover: (input: LocInput) => Effect.Effect<any>
+  readonly definition: (input: LocInput) => Effect.Effect<any[]>
+  readonly references: (input: LocInput) => Effect.Effect<any[]>
+  readonly implementation: (input: LocInput) => Effect.Effect<any[]>
+  readonly documentSymbol: (uri: string) => Effect.Effect<(DocumentSymbol | Symbol)[]>
+  readonly workspaceSymbol: (query: string) => Effect.Effect<Symbol[]>
+  readonly prepareCallHierarchy: (input: LocInput) => Effect.Effect<any[]>
+  readonly incomingCalls: (input: LocInput) => Effect.Effect<any[]>
+  readonly outgoingCalls: (input: LocInput) => Effect.Effect<any[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/LSP") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const config = yield* Config.Service
+
+    const state = yield* InstanceState.make<State>(
+      Effect.fn("LSP.state")(function* () {
+        const cfg = yield* config.get()
+
+        const servers: Record<string, LSPServer.Info> = {}
+
+        if (cfg.lsp === false) {
+          log.info("all LSPs are disabled")
+        } else {
+          for (const server of Object.values(LSPServer)) {
+            servers[server.id] = server
+          }
+
+          filterExperimentalServers(servers)
+
+          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 () => Instance.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) {
+      if (!Instance.containsPath(file)) 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)
+            .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,
+          }).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)
+          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)
+          Bus.publish(Event.Updated, {})
+        }
+
+        return result
+      })
+    })
+
+    const run = Effect.fnUntraced(function* <T>(file: string, fn: (client: LSPClient.Info) => Promise<T>) {
+      const clients = yield* getClients(file)
+      return yield* Effect.promise(() => Promise.all(clients.map((x) => fn(x))))
+    })
+
+    const runAll = Effect.fnUntraced(function* <T>(fn: (client: LSPClient.Info) => Promise<T>) {
+      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 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(Instance.directory, client.root),
+          status: "connected",
+        })
+      }
+      return result
+    })
+
+    const hasClients = Effect.fn("LSP.hasClients")(function* (file: string) {
+      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)
+          if (!root) continue
+          if (s.broken.has(root + server.id)) continue
+          return true
+        }
+        return false
+      })
+    })
+
+    const touchFile = Effect.fn("LSP.touchFile")(function* (input: string, waitForDiagnostics?: boolean) {
+      log.info("touching file", { file: input })
+      const clients = yield* getClients(input)
+      yield* Effect.promise(() =>
+        Promise.all(
+          clients.map(async (client) => {
+            const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
+            await client.notify.open({ path: input })
+            return wait
+          }),
+        ).catch((err) => {
+          log.error("failed to touch file", { err, file: input })
+        }),
+      )
+    })
+
+    const diagnostics = Effect.fn("LSP.diagnostics")(function* () {
+      const results: Record<string, LSPClient.Diagnostic[]> = {}
+      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: any) => result.filter((x: Symbol) => kinds.includes(x.kind)))
+          .then((result: any) => result.slice(0, 10))
+          .catch(() => []),
+      )
+      return results.flat() as Symbol[]
+    })
+
+    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 any[]
+        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))
+
+export namespace Diagnostic {
+  const MAX_PER_FILE = 20
+
+  export function pretty(diagnostic: LSPClient.Diagnostic) {
+    const severityMap = {
+      1: "ERROR",
+      2: "WARN",
+      3: "INFO",
+      4: "HINT",
+    }
+
+    const severity = severityMap[diagnostic.severity || 1]
+    const line = diagnostic.range.start.line + 1
+    const col = diagnostic.range.start.character + 1
+
+    return `${severity} [${line}:${col}] ${diagnostic.message}`
+  }
+
+  export function report(file: string, issues: LSPClient.Diagnostic[]) {
+    const errors = issues.filter((item) => item.severity === 1)
+    if (errors.length === 0) return ""
+    const limited = errors.slice(0, MAX_PER_FILE)
+    const more = errors.length - MAX_PER_FILE
+    const suffix = more > 0 ? `\n... and ${more} more` : ""
+    return `<diagnostics file="${file}">\n${limited.map(pretty).join("\n")}${suffix}\n</diagnostics>`
+  }
+}

packages/opencode/test/lsp/client.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test, beforeEach } from "bun:test"
 import path from "path"
-import { LSPClient } from "../../src/lsp/client"
+import { LSPClient } from "../../src/lsp"
-import { LSPServer } from "../../src/lsp/server"
+import { LSPServer } from "../../src/lsp"
 import { Instance } from "../../src/project/instance"
 import { Log } from "../../src/util"
 

packages/opencode/test/lsp/index.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, spyOn } from "bun:test"
 import path from "path"
 import { Effect, Layer } from "effect"
 import { LSP } from "../../src/lsp"
-import { LSPServer } from "../../src/lsp/server"
+import { LSPServer } from "../../src/lsp"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
 import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

packages/opencode/test/lsp/lifecycle.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
 import path from "path"
 import { Effect, Layer } from "effect"
 import { LSP } from "../../src/lsp"
-import { LSPServer } from "../../src/lsp/server"
+import { LSPServer } from "../../src/lsp"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
 import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"