alchemylab-opencode 1.0.7 → 1.0.9

package/packages/opencode/src/lsp/index.ts

@@ -1,558 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { Log } from "../util/log"
-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/config"
-import { Instance } from "../project/instance"
-import { Flag } from "@/flag/flag"
-import { Process } from "../util/process"
-import { spawn as lspspawn } from "./launch"
-import { Effect, Layer, ServiceMap } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
-
-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 ServiceMap.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 })
-
-            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 (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))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export const init = async () => runPromise((svc) => svc.init())
-
-  export const status = async () => runPromise((svc) => svc.status())
-
-  export const hasClients = async (file: string) => runPromise((svc) => svc.hasClients(file))
-
-  export const touchFile = async (input: string, waitForDiagnostics?: boolean) =>
-    runPromise((svc) => svc.touchFile(input, waitForDiagnostics))
-
-  export const diagnostics = async () => runPromise((svc) => svc.diagnostics())
-
-  export const hover = async (input: LocInput) => runPromise((svc) => svc.hover(input))
-
-  export const definition = async (input: LocInput) => runPromise((svc) => svc.definition(input))
-
-  export const references = async (input: LocInput) => runPromise((svc) => svc.references(input))
-
-  export const implementation = async (input: LocInput) => runPromise((svc) => svc.implementation(input))
-
-  export const documentSymbol = async (uri: string) => runPromise((svc) => svc.documentSymbol(uri))
-
-  export const workspaceSymbol = async (query: string) => runPromise((svc) => svc.workspaceSymbol(query))
-
-  export const prepareCallHierarchy = async (input: LocInput) => runPromise((svc) => svc.prepareCallHierarchy(input))
-
-  export const incomingCalls = async (input: LocInput) => runPromise((svc) => svc.incomingCalls(input))
-
-  export const outgoingCalls = async (input: LocInput) => runPromise((svc) => svc.outgoingCalls(input))
-
-  export namespace Diagnostic {
-    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}`
-    }
-  }
-}

package/packages/opencode/src/lsp/language.ts

@@ -1,120 +0,0 @@
-export const LANGUAGE_EXTENSIONS: Record<string, string> = {
-  ".abap": "abap",
-  ".bat": "bat",
-  ".bib": "bibtex",
-  ".bibtex": "bibtex",
-  ".clj": "clojure",
-  ".cljs": "clojure",
-  ".cljc": "clojure",
-  ".edn": "clojure",
-  ".coffee": "coffeescript",
-  ".c": "c",
-  ".cpp": "cpp",
-  ".cxx": "cpp",
-  ".cc": "cpp",
-  ".c++": "cpp",
-  ".cs": "csharp",
-  ".css": "css",
-  ".d": "d",
-  ".pas": "pascal",
-  ".pascal": "pascal",
-  ".diff": "diff",
-  ".patch": "diff",
-  ".dart": "dart",
-  ".dockerfile": "dockerfile",
-  ".ex": "elixir",
-  ".exs": "elixir",
-  ".erl": "erlang",
-  ".ets": "typescript",
-  ".hrl": "erlang",
-  ".fs": "fsharp",
-  ".fsi": "fsharp",
-  ".fsx": "fsharp",
-  ".fsscript": "fsharp",
-  ".gitcommit": "git-commit",
-  ".gitrebase": "git-rebase",
-  ".go": "go",
-  ".groovy": "groovy",
-  ".gleam": "gleam",
-  ".hbs": "handlebars",
-  ".handlebars": "handlebars",
-  ".hs": "haskell",
-  ".lhs": "haskell",
-  ".html": "html",
-  ".htm": "html",
-  ".ini": "ini",
-  ".java": "java",
-  ".jl": "julia",
-  ".js": "javascript",
-  ".kt": "kotlin",
-  ".kts": "kotlin",
-  ".jsx": "javascriptreact",
-  ".json": "json",
-  ".tex": "latex",
-  ".latex": "latex",
-  ".less": "less",
-  ".lua": "lua",
-  ".makefile": "makefile",
-  makefile: "makefile",
-  ".md": "markdown",
-  ".markdown": "markdown",
-  ".m": "objective-c",
-  ".mm": "objective-cpp",
-  ".pl": "perl",
-  ".pm": "perl",
-  ".pm6": "perl6",
-  ".php": "php",
-  ".ps1": "powershell",
-  ".psm1": "powershell",
-  ".pug": "jade",
-  ".jade": "jade",
-  ".py": "python",
-  ".r": "r",
-  ".cshtml": "razor",
-  ".razor": "razor",
-  ".rb": "ruby",
-  ".rake": "ruby",
-  ".gemspec": "ruby",
-  ".ru": "ruby",
-  ".erb": "erb",
-  ".html.erb": "erb",
-  ".js.erb": "erb",
-  ".css.erb": "erb",
-  ".json.erb": "erb",
-  ".rs": "rust",
-  ".scss": "scss",
-  ".sass": "sass",
-  ".scala": "scala",
-  ".shader": "shaderlab",
-  ".sh": "shellscript",
-  ".bash": "shellscript",
-  ".zsh": "shellscript",
-  ".ksh": "shellscript",
-  ".sql": "sql",
-  ".svelte": "svelte",
-  ".swift": "swift",
-  ".ts": "typescript",
-  ".tsx": "typescriptreact",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".mtsx": "typescriptreact",
-  ".ctsx": "typescriptreact",
-  ".xml": "xml",
-  ".xsl": "xsl",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".vue": "vue",
-  ".zig": "zig",
-  ".zon": "zig",
-  ".astro": "astro",
-  ".ml": "ocaml",
-  ".mli": "ocaml",
-  ".tf": "terraform",
-  ".tfvars": "terraform-vars",
-  ".hcl": "hcl",
-  ".nix": "nix",
-  ".typ": "typst",
-  ".typc": "typst",
-} as const

package/packages/opencode/src/lsp/launch.ts

@@ -1,21 +0,0 @@
-import type { ChildProcessWithoutNullStreams } from "child_process"
-import { Process } from "../util/process"
-
-type Child = Process.Child & ChildProcessWithoutNullStreams
-
-export function spawn(cmd: string, args: string[], opts?: Process.Options): Child
-export function spawn(cmd: string, opts?: Process.Options): Child
-export function spawn(cmd: string, argsOrOpts?: string[] | Process.Options, opts?: Process.Options) {
-  const args = Array.isArray(argsOrOpts) ? [...argsOrOpts] : []
-  const cfg = Array.isArray(argsOrOpts) ? opts : argsOrOpts
-  const proc = Process.spawn([cmd, ...args], {
-    ...(cfg ?? {}),
-    stdin: "pipe",
-    stdout: "pipe",
-    stderr: "pipe",
-  }) as Child
-
-  if (!proc.stdin || !proc.stdout || !proc.stderr) throw new Error("Process output not available")
-
-  return proc
-}