d0029d8d60
Implements the LSP capability seam RFC as three packages: dsh-lsp (the ctx.lsp interface — provider registry by branded id + exclusive extension mapping, per-query order-independent selection, closed request/result vocabulary, LspError taxonomy), dsh-lsp-local (a generic stdio language-server provider — Content-Length JSON-RPC framing, per-(provider, workspace) process single-flight, transient didOpen/query/didClose, an abortable per-instance queue, UTF-16 negotiation, host-namespace source reads outside ctx.fs, and bounded shutdown/kill teardown), and dsh-tool-lsp (the model-facing lsp tool — four operations, one-based UTF-16 cursor conversion, workspace-grouped location rendering, hover capping, a required session workspace, and a timeout budget). Why: an agent had text search and file reads but no way to identify a program symbol — follow an alias, connect an interface to implementations, or read an inferred type — before changing code. Splitting model contract, seam, and local subprocess behavior keeps the four semantic queries stable across future remote or sandbox-native providers without leaking a JSON-RPC escape hatch.
74 lines
3.4 KiB
TypeScript
74 lines
3.4 KiB
TypeScript
import { spawn } from 'node:child_process'
|
|
import { existsSync } from 'node:fs'
|
|
import { mkdtemp, mkdir, rm, writeFile, realpath } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { fileURLToPath, pathToFileURL } from 'node:url'
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
|
|
|
/**
|
|
* Keyless built-artifact smoke: plain Node imports `@deepseek-ai/dsh-lsp` and
|
|
* `@deepseek-ai/dsh-lsp-local` by name through their exports maps, spawns the fixture server, runs
|
|
* one query (exercising real `Content-Length` framing over `lib/index.js`), and disposes (exercising
|
|
* subprocess cleanup). Unit tests use `src/`; this pins the downstream `lib/` path. Skips when `lib/`
|
|
* is absent; CI runs it after the build.
|
|
*/
|
|
|
|
const pkgDir = fileURLToPath(new URL('..', import.meta.url))
|
|
const seamLib = join(pkgDir, '../lsp/lib/index.js')
|
|
const built = existsSync(join(pkgDir, 'lib/index.js')) && existsSync(seamLib)
|
|
|
|
const tsxLoader = fileURLToPath(import.meta.resolve('tsx'))
|
|
const fixtureServer = fileURLToPath(new URL('./fixture-server.ts', import.meta.url))
|
|
const repoTsconfig = fileURLToPath(new URL('../../../../tsconfig.json', import.meta.url))
|
|
|
|
let root: string
|
|
let ws: string
|
|
|
|
beforeAll(async () => {
|
|
root = await realpath(await mkdtemp(join(tmpdir(), 'lsp-built-')))
|
|
ws = join(root, 'ws')
|
|
await mkdir(ws)
|
|
await writeFile(join(ws, 'a.ts'), 'const x = 1\n')
|
|
})
|
|
|
|
afterAll(async () => {
|
|
if (root) await rm(root, { recursive: true, force: true })
|
|
})
|
|
|
|
describe.skipIf(!built)('built lib real load path (plain node)', () => {
|
|
it('runs a query through lib/index.js and disposes cleanly, framing over the base protocol', async () => {
|
|
const location = JSON.stringify({ uri: pathToFileURL(join(ws, 'a.ts')).href, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 3 } } })
|
|
const script = `
|
|
const { Context } = await import('cordis')
|
|
const { default: Lsp } = await import('@deepseek-ai/dsh-lsp')
|
|
const LspLocal = await import('@deepseek-ai/dsh-lsp-local')
|
|
const ctx = new Context()
|
|
await ctx.plugin(Lsp)
|
|
await ctx.plugin(LspLocal, {
|
|
providerId: 'fake',
|
|
command: ${JSON.stringify(process.execPath)},
|
|
args: ['--import', ${JSON.stringify(tsxLoader)}, ${JSON.stringify(fixtureServer)}],
|
|
env: { TSX_TSCONFIG_PATH: ${JSON.stringify(repoTsconfig)}, LSP_FAKE_DEF: ${JSON.stringify(location)} },
|
|
extensionToLanguage: { '.ts': 'typescript' },
|
|
})
|
|
const result = await ctx.lsp.query({ operation: 'definition', filePath: 'a.ts', position: { line: 0, character: 6 }, workspaceRoot: ${JSON.stringify(ws)} })
|
|
console.log(JSON.stringify(result))
|
|
await ctx.fiber.dispose()
|
|
process.exit(0)
|
|
`
|
|
const child = spawn(process.execPath, ['--input-type=module', '-e', script], { cwd: pkgDir, stdio: ['ignore', 'pipe', 'pipe'] })
|
|
let stdout = ''
|
|
let stderr = ''
|
|
child.stdout.on('data', (chunk: Buffer) => { stdout += chunk.toString('utf8') })
|
|
child.stderr.on('data', (chunk: Buffer) => { stderr += chunk.toString('utf8') })
|
|
const exitCode = await new Promise<number | null>(resolve => child.on('close', resolve))
|
|
|
|
expect(exitCode, `stderr:\n${stderr}`).toBe(0)
|
|
const lastLine = stdout.trim().split('\n').at(-1) ?? ''
|
|
const result = JSON.parse(lastLine) as { kind: string; locations: unknown[] }
|
|
expect(result.kind).toBe('locations')
|
|
expect(result.locations).toHaveLength(1)
|
|
}, 60_000)
|
|
})
|