nikcli 0.0.6

package/src/lsp/index.ts

@@ -0,0 +1,483 @@
+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 } from "url"
+import { LSPServer } from "./server"
+import z from "zod"
+import { Config } from "../config/config"
+import { spawn } from "child_process"
+import { Instance } from "../project/instance"
+import { Flag } from "@/flag/flag"
+
+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>
+
+  const filterExperimentalServers = (servers: Record<string, LSPServer.Info>) => {
+    if (Flag.NIKCLI_EXPERIMENTAL_LSP_TY) {
+      if (servers["pyright"]) {
+        log.info("LSP server pyright is disabled because NIKCLI_EXPERIMENTAL_LSP_TY is enabled")
+        delete servers["pyright"]
+      }
+    } else {
+      if (servers["ty"]) {
+        delete servers["ty"]
+      }
+    }
+  }
+
+  const state = Instance.state(
+    async () => {
+      const clients: LSPClient.Info[] = []
+      const servers: Record<string, LSPServer.Info> = {}
+      const cfg = await Config.get()
+
+      if (cfg.lsp === false) {
+        log.info("all LSPs are disabled")
+        return {
+          broken: new Set<string>(),
+          servers,
+          clients,
+          spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
+        }
+      }
+
+      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) => {
+            return {
+              process: spawn(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(", "),
+      })
+
+      return {
+        broken: new Set<string>(),
+        servers,
+        clients,
+        spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
+      }
+    },
+    async (state) => {
+      await Promise.all(state.clients.map((client) => client.shutdown()))
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  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>
+
+  export async function status() {
+    return state().then((x) => {
+      const result: Status[] = []
+      for (const client of x.clients) {
+        result.push({
+          id: client.serverID,
+          name: x.servers[client.serverID].id,
+          root: path.relative(Instance.directory, client.root),
+          status: "connected",
+        })
+      }
+      return result
+    })
+  }
+
+  async function getClients(file: string) {
+    const s = await state()
+    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((err) => {
+        s.broken.add(key)
+        handle.process.kill()
+        log.error(`Failed to initialize LSP client ${server.id}`, { error: err })
+        return undefined
+      })
+
+      if (!client) {
+        handle.process.kill()
+        return undefined
+      }
+
+      const existing = s.clients.find((x) => x.root === root && x.serverID === server.id)
+      if (existing) {
+        handle.process.kill()
+        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
+  }
+
+  export async function hasClients(file: string) {
+    const s = await state()
+    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
+  }
+
+  export async function touchFile(input: string, waitForDiagnostics?: boolean) {
+    log.info("touching file", { file: input })
+    const clients = await getClients(input)
+    await 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 })
+    })
+  }
+
+  export async function diagnostics() {
+    const results: Record<string, LSPClient.Diagnostic[]> = {}
+    for (const result of await runAll(async (client) => client.diagnostics)) {
+      for (const [path, diagnostics] of result.entries()) {
+        const arr = results[path] || []
+        arr.push(...diagnostics)
+        results[path] = arr
+      }
+    }
+    return results
+  }
+
+  export async function hover(input: { file: string; line: number; character: number }) {
+    return run(input.file, (client) => {
+      return client.connection
+        .sendRequest("textDocument/hover", {
+          textDocument: {
+            uri: pathToFileURL(input.file).href,
+          },
+          position: {
+            line: input.line,
+            character: input.character,
+          },
+        })
+        .catch(() => null)
+    })
+  }
+
+  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,
+  ]
+
+  export async function workspaceSymbol(query: string) {
+    return 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(() => []),
+    ).then((result) => result.flat() as LSP.Symbol[])
+  }
+
+  export async function documentSymbol(uri: string) {
+    const file = new URL(uri).pathname
+    return run(file, (client) =>
+      client.connection
+        .sendRequest("textDocument/documentSymbol", {
+          textDocument: {
+            uri,
+          },
+        })
+        .catch(() => []),
+    )
+      .then((result) => result.flat() as (LSP.DocumentSymbol | LSP.Symbol)[])
+      .then((result) => result.filter(Boolean))
+  }
+
+  export async function definition(input: { file: string; line: number; character: number }) {
+    return run(input.file, (client) =>
+      client.connection
+        .sendRequest("textDocument/definition", {
+          textDocument: { uri: pathToFileURL(input.file).href },
+          position: { line: input.line, character: input.character },
+        })
+        .catch(() => null),
+    ).then((result) => result.flat().filter(Boolean))
+  }
+
+  export async function references(input: { file: string; line: number; character: number }) {
+    return 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(() => []),
+    ).then((result) => result.flat().filter(Boolean))
+  }
+
+  export async function implementation(input: { file: string; line: number; character: number }) {
+    return run(input.file, (client) =>
+      client.connection
+        .sendRequest("textDocument/implementation", {
+          textDocument: { uri: pathToFileURL(input.file).href },
+          position: { line: input.line, character: input.character },
+        })
+        .catch(() => null),
+    ).then((result) => result.flat().filter(Boolean))
+  }
+
+  export async function prepareCallHierarchy(input: { file: string; line: number; character: number }) {
+    return run(input.file, (client) =>
+      client.connection
+        .sendRequest("textDocument/prepareCallHierarchy", {
+          textDocument: { uri: pathToFileURL(input.file).href },
+          position: { line: input.line, character: input.character },
+        })
+        .catch(() => []),
+    ).then((result) => result.flat().filter(Boolean))
+  }
+
+  export async function incomingCalls(input: { file: string; line: number; character: number }) {
+    return 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("callHierarchy/incomingCalls", { item: items[0] }).catch(() => [])
+    }).then((result) => result.flat().filter(Boolean))
+  }
+
+  export async function outgoingCalls(input: { file: string; line: number; character: number }) {
+    return 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("callHierarchy/outgoingCalls", { item: items[0] }).catch(() => [])
+    }).then((result) => result.flat().filter(Boolean))
+  }
+
+  async function runAll<T>(input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+    const clients = await state().then((x) => x.clients)
+    const tasks = clients.map((x) => input(x))
+    return Promise.all(tasks)
+  }
+
+  async function run<T>(file: string, input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+    const clients = await getClients(file)
+    const tasks = clients.map((x) => input(x))
+    return Promise.all(tasks)
+  }
+
+  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/src/lsp/language.ts

@@ -0,0 +1,119 @@
+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",
+  ".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