tulingcode 0.1.0

package/src/lsp/language.ts

@@ -0,0 +1,120 @@
+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/src/lsp/launch.ts

@@ -0,0 +1,21 @@
+import type { ChildProcessWithoutNullStreams } from "child_process"
+import { Process } from "../util"
+
+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

@@ -0,0 +1,519 @@
+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 "@/flag/flag"
+import { Process } from "../util"
+import { spawn as lspspawn } from "./launch"
+import { Effect, Layer, Context } from "effect"
+import { InstanceState } from "@/effect"
+import { AppFileSystem } from "@tuling-ai/shared/filesystem"
+
+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.tulingcode_EXPERIMENTAL_LSP_TY) {
+    if (servers["pyright"]) {
+      log.info("LSP server pyright is disabled because tulingcode_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>()("@tulingcode/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, 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<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"