@miaws/miaw 1.18.5 → 1.18.6

package/src/lsp/language.ts

@@ -1,121 +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",
-  ".csx": "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/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
-}

package/src/lsp/lsp.ts

@@ -1,511 +0,0 @@
-import { LayerNode } from "@miaw/core/effect/layer-node"
-import { FSUtil } from "@miaw/core/fs-util"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { EventV2 } from "@miaw/core/event"
-import * as LSPClient from "./client"
-import path from "path"
-import { pathToFileURL, fileURLToPath } from "url"
-import * as LSPServer from "./server"
-import { Config } from "@/config/config"
-import { Process } from "@/util/process"
-import { spawn as lspspawn } from "./launch"
-import { Effect, Layer, Context, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { containsPath } from "@/project/instance-context"
-import { NonNegativeInt } from "@miaw/core/schema"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-
-export const Event = {
-  Updated: EventV2.define({ type: "lsp.updated", schema: {} }),
-}
-
-const Position = Schema.Struct({
-  line: NonNegativeInt,
-  character: NonNegativeInt,
-})
-
-export const Range = Schema.Struct({
-  start: Position,
-  end: Position,
-}).annotate({ identifier: "Range" })
-export type Range = typeof Range.Type
-
-export const Symbol = Schema.Struct({
-  name: Schema.String,
-  kind: NonNegativeInt,
-  location: Schema.Struct({
-    uri: Schema.String,
-    range: Range,
-  }),
-}).annotate({ identifier: "Symbol" })
-export type Symbol = typeof Symbol.Type
-
-export const DocumentSymbol = Schema.Struct({
-  name: Schema.String,
-  detail: Schema.optional(Schema.String),
-  kind: NonNegativeInt,
-  range: Range,
-  selectionRange: Range,
-}).annotate({ identifier: "DocumentSymbol" })
-export type DocumentSymbol = typeof DocumentSymbol.Type
-
-export const Status = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  root: Schema.String,
-  status: Schema.Literals(["connected", "error"]),
-}).annotate({ identifier: "LSPStatus" })
-export type Status = typeof Status.Type
-
-enum SymbolKind {
-  File = 1,
-  Module = 2,
-  Namespace = 3,
-  Package = 4,
-  Class = 5,
-  Method = 6,
-  Property = 7,
-  Field = 8,
-  Constructor = 9,
-  Enum = 10,
-  Interface = 11,
-  Function = 12,
-  Variable = 13,
-  Constant = 14,
-  String = 15,
-  Number = 16,
-  Boolean = 17,
-  Array = 18,
-  Object = 19,
-  Key = 20,
-  Null = 21,
-  EnumMember = 22,
-  Struct = 23,
-  Event = 24,
-  Operator = 25,
-  TypeParameter = 26,
-}
-
-const kinds = [
-  SymbolKind.Class,
-  SymbolKind.Function,
-  SymbolKind.Method,
-  SymbolKind.Interface,
-  SymbolKind.Variable,
-  SymbolKind.Constant,
-  SymbolKind.Struct,
-  SymbolKind.Enum,
-]
-
-const filterExperimentalServers = (servers: Record<string, LSPServer.Info>, flags: RuntimeFlags.Info) => {
-  if (flags.experimentalLspTy) {
-    if (servers["pyright"]) {
-      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>()("@miaw/LSP") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const flags = yield* RuntimeFlags.Service
-    const events = yield* EventV2Bridge.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) {
-          yield* Effect.logInfo("all LSPs are disabled")
-        } else {
-          for (const server of Object.values(LSPServer)) {
-            servers[server.id] = server
-          }
-
-          filterExperimentalServers(servers, flags)
-
-          if (cfg.lsp !== true) {
-            for (const [name, item] of Object.entries(cfg.lsp)) {
-              const existing = servers[name]
-              if (item.disabled) {
-                yield* Effect.logInfo(`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,
-                }),
-              }
-            }
-          }
-
-          yield* Effect.logInfo("enabled LSP servers", {
-            serverIds: Object.values(servers)
-              .map((server) => server.id)
-              .join(", "),
-          })
-        }
-
-        const s: State = {
-          clients: [],
-          servers,
-          broken: new Set(),
-          spawning: new Map(),
-        }
-
-        yield* Effect.addFinalizer(() =>
-          Effect.promise(async () => {
-            await Promise.all(s.clients.map((client) => client.shutdown()))
-          }),
-        )
-
-        return s
-      }),
-    )
-
-    const getClients = Effect.fnUntraced(function* (file: string) {
-      const ctx = yield* InstanceState.context
-      if (!containsPath(file, ctx)) return [] as LSPClient.Info[]
-      const s = yield* InstanceState.get(state)
-      const clients = yield* Effect.promise(async () => {
-        const extension = path.parse(file).ext || file
-        const result: LSPClient.Info[] = []
-        let updated = 0
-
-        async function schedule(server: LSPServer.Info, root: string, key: string) {
-          const handle = await server
-            .spawn(root, ctx, flags)
-            .then((value) => {
-              if (!value) s.broken.add(key)
-              return value
-            })
-            .catch(() => {
-              s.broken.add(key)
-              return undefined
-            })
-
-          if (!handle) return undefined
-          const client = await LSPClient.create({
-            serverID: server.id,
-            server: handle,
-            root,
-            directory: ctx.directory,
-            instance: ctx,
-          }).catch(async () => {
-            s.broken.add(key)
-            await Process.stop(handle.process)
-            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)
-          updated++
-        }
-
-        return { result, updated }
-      })
-      yield* Effect.forEach(Array.from({ length: clients.updated }), () => events.publish(Event.Updated, {}), {
-        discard: true,
-      })
-      return clients.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") {
-      yield* Effect.logInfo("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(() => {}),
-      )
-    })
-
-    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),
-  Layer.provide(RuntimeFlags.defaultLayer),
-  Layer.provide(EventV2Bridge.defaultLayer),
-)
-
-export * as Diagnostic from "./diagnostic"
-
-export const node = LayerNode.make(layer, [Config.node, RuntimeFlags.node, FSUtil.node, EventV2Bridge.node])
-
-export * as LSP from "./lsp"