jet.nvim provides an 'expression' text object, which can be used to send discrete chunks of code to the Jet repl. The textobject is configurable per filetype, so for example, installing jet.nvim extensions like jet.ark will give better expression detection in R scripts.

In the demo below, ]e and [e are used to go the next/previous expression, and ie is used as the expression textobject. These compose nicely, so e.g. the following keymap can be used to send the current expression to the repl with a single keypress:

vim.keymap.set("n", "<enter>", "goie]e", { remap = true })

The Jet CLI allows multiple users to connect to the same kernel session. Jet provides a simple skill teaching AI agents how to do this. Agent code is clearly marked as such in the repl:

Why is this kind of AI integration useful? Say you have some Python code which produces a single DataFrame and takes 10 minutes to run. Once you have the resulting DataFrame loaded in your Python session, to perform any analysis using AI in a traditional workflow, you will either need to first tell the AI how to reproduce the DataFrame, or serialise it to a file which the AI can quickly read. Both of these options take time and introduce plenty of room for things to go wrong. Using Jet, the AI acts as 'player 2' in your session and can work with the data directly. This can save a tonne of time, and greatly reduces context/token usage for certain types of problems.

jet.nvim provides kernel completions via an LSP middle-layer. These can include runtime information not available to other LSP servers, e.g. the column names in a Pandas DataFrame:

jet.nvim provides a UI for kernel management, allowing you to easily start, stop or rename kernel sessions from Neovim:

jet.nvim supports running many kernels simultaneously, and each kernel may also run many instances. get_kernel() uses some heuristics to determine the best kernel to use; see the docs for more information:

local toggle_repl = function(ft)
	return function()
		require("jet.api").get_kernel({ filetype = ft }, function(k) k:term_toggle() end)
	end
end

vim.keymap.set("n", "<leader>jp", toggle_repl("python"), { desc = "Open Python (Jet)" })
vim.keymap.set("n", "<leader>jr", toggle_repl("r"), { desc = "Open R (Jet)" })

The Jet repl and image buffers set vim.b.jet.session_id, which can be used to get the Kernel object which 'owns' the buffers. This mechanism can be used to set toggle keymaps like so:

vim.api.nvim_create_autocmd("BufWinEnter", {
	callback = function()
		local session_id = vim.b.jet and vim.b.jet.session_id
		local k = session_id and require("jet.api").get_kernel_by_id(session_id)
		if k then
			vim.keymap.set({ "n", "t" }, "<c-o>", function() k:img_toggle() end, { buffer = 0 })
		end
	end,
})

The following keymap adds go as an operator which sends the current motion to the repl. So, for example, goi( will send everything within the current parentheses to an active jet repl matching the current filetype:

vim.keymap.set(
	{ "n", "x" },
	"go",
	require("jet.api").handle_motion(function(range, filetype)
		require("jet.api").get_kernel({
			filetype = filetype,
			current = true,
			status = { "connected", "connecting" },
		}, function(k)
			local code = range:code({ comments = false })
			if code then
				k:send_repl(code)
			end
		end)
	end),
	{ desc = "Execute code (Jet)", expr = true }
)

Jet allows you to configure what a current 'expression' looks like for a given language. For jet.nvim's purposes, an expression is just the smallest block of code around (or ahead of) the cursor which it makes sense to send to the kernel in one go. This works great with go above, so with the combined mappings you could use goie to send the current/next expression to the repl:

local api = require("jet.api")

vim.keymap.set({ "x", "o" }, "ie", function()
	local expr = api.get_expr()
	if not expr then
		local pos = api.next_expr_boundary({
			current_ok = false,
			boundary = "start",
		})
		expr = pos and api.get_expr(pos)
	end
	if expr then
		expr:textobject()
	end
end, { desc = "textobject (jet): [i]n [e]xpression" })

]e and [e can be used to navigate between 'expressions':

vim.keymap.set("n", "]e", function()
	local pos = api.next_expr_boundary({ direction = 1, boundary = "start" })
	if pos then
		vim.fn.cursor(pos:to_cursor())
	end
end)
vim.keymap.set("n", "[e", function()
	local pos = api.next_expr_boundary({ direction = -1, boundary = "start" })
	if pos then
		vim.fn.cursor(pos:to_cursor())
	end
end)

Finally, if you like to blast through a script sending expressions to the repl as you go, you might like a mapping to send the current expression and move to the next one in a single keypress:

vim.keymap.set("n", "<enter>", "goie]e", { remap = true })
vim.keymap.set("x", "<enter>", "go", { remap = true })