chore: initialize qiming workspace repository

qimingcode/packages/opencode/src/lsp/lsp.ts

@@ -0,0 +1,520 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { Log } from "../util"
+import * as LSPClient from "./client"
+import path from "path"
+import { pathToFileURL, fileURLToPath } from "url"
+import * as LSPServer from "./server"
+import z from "zod"
+import { Config } from "../config"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { Process } from "../util"
+import { spawn as lspspawn } from "./launch"
+import { Effect, Layer, Context, Schema } from "effect"
+import { InstanceState } from "@/effect"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { withStatics } from "@/util/schema"
+import { zod, ZodOverride } from "@/util/effect-zod"
+
+const log = Log.create({ service: "lsp" })
+
+export const Event = {
+  Updated: BusEvent.define("lsp.updated", Schema.Struct({})),
+}
+
+const Position = Schema.Struct({
+  line: Schema.Number,
+  character: Schema.Number,
+})
+
+export const Range = Schema.Struct({
+  start: Position,
+  end: Position,
+})
+  .annotate({ identifier: "Range" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Range = typeof Range.Type
+
+export const Symbol = Schema.Struct({
+  name: Schema.String,
+  kind: Schema.Number,
+  location: Schema.Struct({
+    uri: Schema.String,
+    range: Range,
+  }),
+})
+  .annotate({ identifier: "Symbol" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Symbol = typeof Symbol.Type
+
+export const DocumentSymbol = Schema.Struct({
+  name: Schema.String,
+  detail: Schema.optional(Schema.String),
+  kind: Schema.Number,
+  range: Range,
+  selectionRange: Range,
+})
+  .annotate({ identifier: "DocumentSymbol" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+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({
+    [ZodOverride]: z.union([z.literal("connected"), z.literal("error")]),
+  }),
+})
+  .annotate({ identifier: "LSPStatus" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+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<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, diagnostics?: "document" | "full") => 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* (ctx) {
+        const cfg = yield* config.get()
+
+        const servers: Record<string, LSPServer.Info> = {}
+
+        if (!cfg.lsp) {
+          log.info("all LSPs are disabled")
+        } else {
+          for (const server of Object.values(LSPServer)) {
+            servers[server.id] = server
+          }
+
+          filterExperimentalServers(servers)
+
+          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 (
+        !AppFileSystem.contains(ctx.directory, file) &&
+        (ctx.worktree === "/" || !AppFileSystem.contains(ctx.worktree, 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, ctx)
+            .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,
+          }).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)
+          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 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<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<Symbol[]>("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<unknown[] | null>("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))
+
+export * as Diagnostic from "./diagnostic"