[atusy]

What

Lets completion UIs other than Neovim's builtin menu use skkelua's candidates, through the in-process LSP server rather than a parallel Lua API. This is a rework of #1 following the maintainer's direction that SKK conversion logic should live in the LSP server as much as possible; #1 is left open for reference and can be closed once this one is accepted.

• Candidates stay in the server. Candidate generation and the UI-independent CompletionList are internal to lsp/ (lsp/candidates.lua, lsp/list.lua); there is no public get().
• Learning and registration are LSP commands. Each item carries command = skkelua.accept; the server declares it in executeCommandProvider and handles workspace/executeCommand. Clients run an item's command only when it is confirmed, so cancelling (<C-e>, <Esc>) needs no special casing. This replaces the CompleteDone autocmd, and there is no accept() fallback in Lua.
• require("skkelua.lsp").start(bufnr) attaches a buffer to one shared client (kept across SKK enable/disable, builtin UI not enabled) that returns the UI-independent list.
• require("skkelua.completion").set_adapter({selected, confirm}) is the only UI-specific hook left. The server cannot know which item a menu has selected or how to confirm it, so the UI reports them: selected() returns the selected LSP CompletionItem (or nil), and confirm() returns the keys that confirm it. pum.vim and nvim-cmp are still auto-detected through the same seam; an explicit adapter wins.
• User skkelua-pre-edit-restored fires when the pre-edit is restored without typing (e.g. cancelling the registration prompt). Autotrigger does not run then, so a UI re-requests completion from this event; builtin completion is still re-requested by skkelua.

Try it with laser.nvim

Minimal config (laser.nvim completing with skkelua's candidates)

Save as minimal.lua and run NVIM_APPNAME=skkelua-minimal nvim -u minimal.lua (needs Neovim with vim.pack). In insert mode, <C-j> enables SKK and Kanji lists the candidates; <C-n>/<C-p> select, <C-y> confirms and teaches skkelua, <C-e> closes.

-- Minimal reproduction: laser.nvim completing with skkelua's candidates.
-- Run: NVIM_APPNAME=skkelua-minimal nvim -u __ignored/minimal.lua
-- To refetch the plugins, remove ~/.config/skkelua-minimal (vim.pack's lockfile pins revisions)
-- and ~/.local/share/skkelua-minimal. (--clean does not put the plugin directory vim.pack installs into on 'packpath')
-- Then in insert mode: <C-j> (enable SKK), type "Kanji" -> laser lists 漢字, 感じ, ...
-- <C-n>/<C-p> select, <C-y> confirms (and teaches skkelua), <C-e> closes.
vim.g.mapleader = " "

vim.pack.add({
	"https://github.com/atusy/laser.nvim",
	{ src = "https://github.com/atusy/skkelua.nvim", version = "feat/lsp-external-completion" },
}, { confirm = false })

-- A tiny dictionary so that no download is needed.
local dict = vim.fn.tempname()
vim.fn.writefile({
	";; -*- coding: utf-8 -*-",
	";; okuri-ari entries.",
	";; okuri-nasi entries.",
	"かんじ /漢字/感じ/幹事/",
	"かな /仮名/",
}, dict)

local skkelua = require("skkelua")
skkelua.config({
	sources = { "skk_dictionary" },
	globalDictionaries = { dict },
	userDictionary = vim.fn.tempname(),
})
vim.keymap.set({ "i", "c" }, "<C-j>", "<Plug>(skkelua-enable)")

local laser = require("laser")

-- 1. skkelua's LSP client must be attached to the buffer for laser to ask it.
vim.api.nvim_create_autocmd("InsertEnter", {
	callback = function()
		require("skkelua.lsp").start()
	end,
})

-- 2. Tell skkelua which candidate laser has selected, and how to confirm it.
--    laser runs the candidate's command on confirm, which makes skkelua learn.
require("skkelua.completion").set_adapter({
	selected = function()
		if not laser.visible() then
			return nil
		end
		local ui = laser._engine().ui
		local candidate = ui.items()[ui.selected()]
		return candidate and vim.tbl_get(candidate, "user_data", "laser", "item") or nil
	end,
	confirm = function()
		return vim.keycode("<Cmd>lua require('laser').confirm()<CR>")
	end,
})

-- 3. Completion does not start by itself when the pre-edit is restored without typing.
vim.api.nvim_create_autocmd("User", {
	pattern = "skkelua-pre-edit-restored",
	callback = function()
		laser.complete()
	end,
})

-- laser itself: complete as you type, and map the menu keys.
vim.api.nvim_create_autocmd({ "InsertEnter", "TextChangedI", "LspAttach" }, {
	callback = function()
		laser.complete()
	end,
})
local function map(key, action)
	vim.keymap.set("i", key, function()
		if laser.visible() then
			return action()
		end
		return key
	end, { expr = true })
end
map("<C-n>", function()
	return "<Cmd>lua require('laser').select(1)<CR>"
end)
map("<C-p>", function()
	return "<Cmd>lua require('laser').select(-1)<CR>"
end)
map("<C-y>", function()
	return "<Cmd>lua require('laser').confirm()<CR>"
end)
map("<C-e>", function()
	return "<Cmd>lua require('laser').cancel()<CR>"
end)

Notes for review

• Builtin menu behavior is unchanged: the list, ordering, insertOnSelect shaping and deferOkuri auto-select were compared against origin/master item by item. The one deliberate difference is that learning now happens one scheduled tick later than the old synchronous CompleteDone handler; <C-y>/<CR> on a dictionary item are still finalized by skkelua itself and learn synchronously.
• A UI must run the item's command on confirm for learning and [辞書登録] to work; the help says so, including for the auto-detected pum.vim/nvim-cmp (nvim-cmp does).
• completeType in vim_status() is now "external" for pum.vim/nvim-cmp (was "pum.vim"/"cmp"), and completeInfo.selected is 0/-1 for them.
• All unnamed buffers share one URI, so the current buffer is taken as the requester; a stale request from another unnamed buffer finds no pre-edit and gets no candidates (documented).

Testing

nvim --clean --headless -l tests/run.lua passes. New coverage includes a real builtin menu (vim.lsp.completion) selecting and confirming/cancelling items, a real Client:exec_cmd round trip, shared-client reuse/separation in both attach orders, error replies for unsupported requests, pum.vim/nvim-cmp selection, and the skkelua-pre-edit-restored event.

🤖 Generated with Claude Code