[FEATURE] Add Neovim command to "send text to the currently-open claude code pane"

[ColinKennedy]

Feature Description

For the sake of easier scripting, it'd be great to have a function that can be called to just type a command as if the cursor was focused on the claude code window.

Use Case

Being able to programmatically do things with the plugin.

Alternatives Considered

I could roll my own but it'd be better if the plugin itself supported this.

[mikedecr]

just fyi for anybody interested, this works out of the box w/ vim-slime if it is configured to send to neovim terminal, since claude runs in a terminal buffer

[ThomasK33]

Note

This triage report is AI-generated using Claude Code

Summary

This is a feature request (not a bug), and it is both in scope and cheap to implement. The core mechanism it depends on was verified end-to-end against the real Claude Code CLI (v2.1.168) running inside the plugin's terminal.

Headline finding: writing to the Claude terminal's job channel with vim.fn.chansend(chan, text .. "\r") both inserts the text into Claude's prompt and submits it — and no window focus is required, which is exactly what the "for scripting" use case needs.

Current behaviour / the gap

There is currently no way to send arbitrary text into the Claude pane. :ClaudeCodeSend / M.send_at_mention push an MCP at_mentioned WebSocket message (file/selection context) — they never type into the terminal. No chansend/jobsend call exists anywhere in the plugin; the terminal providers only manage visibility and focus. So the capability requested here genuinely does not exist today.

Empirical verification

The real claude CLI was driven inside the plugin's native terminal via agent-tty. Text was written to the terminal job channel resolved the way a real feature would resolve it — vim.b[bufnr].terminal_job_id, where bufnr comes from the plugin's own require("claudecode.terminal").get_active_terminal_bufnr():

Mechanism	Result
chansend(chan, "ZZAAA_chansend_insert")	✅ text appears in Claude's ❯ prompt box (insert)
chansend(chan, "\r")	✅ submits — Claude ran a Bash(grep …) tool and replied
chansend(chan, "What is 2+2?…\r") (single call)	✅ submits — Claude replied 4

Throughout the test the cursor remained in a separate, unfocused [No Name] buffer; the terminal was never focused. Programmatic send therefore needs no focus.

Important

A natural objection is anthropics/claude-code#15553 — "Ink's ink-text-input won't submit on a programmatic \r/\n". That report is about VS Code's terminal.sendText / AppleScript, a different layer. Inside a Neovim :terminal, Neovim is the PTY master, so a chansend("\r") byte is identical to Neovim forwarding a real Enter — and it submits. #15553 does not appear to apply to the Neovim-terminal path.

Prior art

• vim-slime (the workaround already suggested in this thread) and toggleterm.nvim both implement exactly this: chansend(job_id, …) into a terminal job, with bracketed paste for multi-line payloads. The mechanism matches.
• avante.nvim / codecompanion.nvim drive their own buffers or in-process LLM calls, so they are not directly comparable to typing into an external CLI.
• Internally, this is the same primitive that [FEATURE] Send prompt with selection to Claude Code #234 (prompt-with-selection) would build on, and it is adjacent to [FEATURE] terminal context sharing #229 (terminal context sharing).

Scope & caveats

• In-editor providers only (native, snacks). For external / none, get_active_terminal_bufnr() returns nil (there is no in-Neovim terminal to write to). A command should warn or no-op gracefully in that case — the same provider-coupling consideration already documented for focus_after_send and the ClaudeCodeSendComplete event.
• The submit byte is \r (carriage return = Enter), not \n.
• Multi-line payloads should be wrapped in bracketed paste (\27[200~ … \27[201~) followed by a separate \r, mirroring vim-slime. This repo already streams bracketed pastes to Claude (see paste_fix.lua and the fixtures/paste-repro work), so it is well-trodden ground.

Recommendation

1. The feature is reasonable to adopt. It is a small (~15–30 line) addition that would also unblock #234. A possible shape:

-- M.send_to_terminal(text, { submit = true })  +  :ClaudeCodeSendText <text>
local bufnr = require("claudecode.terminal").get_active_terminal_bufnr()
if not bufnr then return end -- warn for external/none providers
local chan = vim.b[bufnr].terminal_job_id
vim.fn.chansend(chan, (opts.submit ~= false) and (text .. "\r") or text)

Making submit configurable would match CodeCompanion's cli(prompt, { submit = true }) precedent; multi-line input should use bracketed paste plus a trailing \r.

2. A workaround is already available today — no plugin change required. Because get_active_terminal_bufnr() is already part of the public surface, the following can be dropped into a user config right now:

vim.api.nvim_create_user_command("ClaudeSend", function(o)
  local b = require("claudecode.terminal").get_active_terminal_bufnr()
  if not b then
    return vim.notify("Claude terminal not open", vim.log.levels.WARN)
  end
  vim.fn.chansend(vim.b[b].terminal_job_id, o.args .. "\r")
end, { nargs = "+" })

(Alternatively, vim-slime with g:slime_target = "neovim", as noted earlier in the thread.)

3. There is a small documentation gap. Whichever direction is chosen, the README would benefit from documenting the in-editor-providers-only constraint, and pointing external/none users at the ClaudeCodeSendComplete event for focusing an out-of-editor session.

---

The reproduction is self-contained and modeled on the existing fixtures/paste-repro/agent-repro.sh. The two prototype files and a redacted capture of the result are included below for review.

Prototype fixture — init.lua

Loads the real plugin (native provider), opens the real claude CLI in the plugin's managed terminal without focusing it, and exposes prototype :Proto* commands that write into the terminal job channel via chansend — i.e. exactly what a "send text to the Claude pane" feature would do.

-- Prototype fixture for issue #197:
-- "Add Neovim command to send text to the currently-open Claude Code pane".

local repo_root = os.getenv("CLAUDECODE_REPO") or vim.fn.getcwd()
vim.opt.rtp:prepend(repo_root)

vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

local ok, claudecode = pcall(require, "claudecode")
assert(ok, "Failed to load claudecode.nvim from repo root: " .. tostring(claudecode))

claudecode.setup({
  auto_start = true, -- start WS server so the launched claude connects to the IDE (realistic)
  log_level = "info",
  terminal = {
    provider = "native",
    auto_close = false,
    split_width_percentage = 0.6, -- wide enough that claude's prompt box renders readably
  },
})

local log_path = os.getenv("PROTO_LOG") or (vim.fn.stdpath("cache") .. "/proto197.log")
local function logmsg(s)
  local f = io.open(log_path, "a")
  if f then
    f:write(s .. "\n")
    f:close()
  end
end

-- Resolve the active Claude terminal's job channel the way a real feature would:
-- get the active terminal bufnr from the plugin, then read its terminal job id.
local function term_chan()
  local term = require("claudecode.terminal")
  local bufnr = term.get_active_terminal_bufnr()
  if not bufnr then
    return nil, "no active terminal bufnr"
  end
  local chan = vim.b[bufnr].terminal_job_id
  if not chan or chan == 0 then
    chan = vim.bo[bufnr].channel
  end
  return chan, string.format("bufnr=%s terminal_job_id=%s channel=%s",
    tostring(bufnr), tostring(vim.b[bufnr].terminal_job_id), tostring(vim.bo[bufnr].channel))
end

vim.api.nvim_create_user_command("ProtoInfo", function()
  local chan, info = term_chan()
  logmsg("[ProtoInfo] " .. tostring(info) .. " -> chan=" .. tostring(chan))
end, {})

vim.api.nvim_create_user_command("ProtoInsert", function(o)
  local chan, info = term_chan()
  logmsg("[ProtoInsert] " .. tostring(info))
  if chan then
    vim.fn.chansend(chan, o.args)
  end
end, { nargs = "+" })

vim.api.nvim_create_user_command("ProtoSubmitCR", function()
  local chan = term_chan()
  logmsg("[ProtoSubmitCR] chan=" .. tostring(chan))
  if chan then
    vim.fn.chansend(chan, "\r")
  end
end, {})

vim.api.nvim_create_user_command("ProtoPaste", function(o)
  local chan = term_chan()
  if chan then
    vim.fn.chansend(chan, "\27[200~" .. o.args .. "\27[201~")
  end
end, { nargs = "+" })

-- Open the Claude terminal WITHOUT focus so the cursor stays in the startup
-- (normal) buffer; an external driver can then type ":Proto..." directly.
vim.defer_fn(function()
  pcall(function()
    return claudecode.start(false)
  end)
  require("claudecode.terminal").ensure_visible({}, nil) -- opens unfocused
end, 400)

Prototype driver — drive.sh (agent-tty)

Paths anonymized. Run from a claudecode.nvim checkout with the init.lua above saved into $PROTO.

#!/usr/bin/env bash
# Drive the issue-#197 prototype: open the REAL claude CLI inside the plugin's
# Neovim terminal and test whether `chansend` into the terminal job can
# (a) insert text into Claude's prompt and (b) SUBMIT it.
set -uo pipefail

REPO="${CLAUDECODE_REPO:-$(pwd)}"     # a claudecode.nvim checkout
PROTO="${PROTO_DIR:-/tmp/proto-197}"  # scratch dir holding init.lua (see other box)
export CLAUDECODE_REPO="$REPO"
AGENT_HOME="$PROTO/atty-home"
PROTO_LOG="$PROTO/proto197.log"
mkdir -p "$AGENT_HOME"
rm -f "$PROTO_LOG"

a() { agent-tty --home "$AGENT_HOME" "$@"; }
snap() { a snapshot "$1" --format text --json 2>/dev/null \
  | python3 -c "import json,sys; print(json.load(sys.stdin)['result'].get('text',''))"; }
excmd() { # excmd <sid> <ex-command-without-leading-colon>
  a type "$1" ":$2" --json >/dev/null 2>&1
  a send-keys "$1" Enter --json >/dev/null 2>&1
}

SID=$(a create --json --cols 175 --rows 45 -- \
  bash -lc "cd '$REPO' && PROTO_LOG='$PROTO_LOG' CLAUDECODE_REPO='$REPO' nvim --clean -u '$PROTO/init.lua'" \
  | python3 -c "import json,sys;print(json.load(sys.stdin)['result']['sessionId'])")
echo "session: $SID"

echo "Waiting for claude prompt to be ready..."
a wait "$SID" --text 'shift+tab' --timeout-ms 35000 --json >/dev/null 2>&1
a wait "$SID" --screen-stable-ms 1500 --timeout-ms 10000 --json >/dev/null 2>&1
echo "=== [0] READY ==="; snap "$SID"

excmd "$SID" "ProtoInfo"; sleep 0.3

echo "######## TEST 1: chansend(text) then chansend(CR) ########"
excmd "$SID" "ProtoInsert ZZAAA_chansend_insert"
a wait "$SID" --screen-stable-ms 800 --timeout-ms 5000 --json >/dev/null 2>&1
echo "=== [1a] after ProtoInsert (expect text in claude prompt box) ==="; snap "$SID"

excmd "$SID" "ProtoSubmitCR"
a wait "$SID" --screen-stable-ms 1500 --timeout-ms 8000 --json >/dev/null 2>&1
echo "=== [1b] after ProtoSubmitCR (if SUBMITTED: input clears + response) ==="; snap "$SID"

echo "=== PROTO_LOG ==="; cat "$PROTO_LOG" 2>/dev/null
# A single-call variant was also confirmed via a :lua one-liner:
#   :lua local t=require('claudecode.terminal'); local b=t.get_active_terminal_bufnr();
#        vim.fn.chansend(vim.b[b].terminal_job_id, 'What is 2+2? Reply with ONLY the digit.\r')
# -> Claude replied "4".

Reproduction output (redacted) — the Claude pane after two chansend submits

The left split was an unfocused [No Name] buffer; the right split is Claude rendered in the plugin's native :terminal. Both prompts below were inserted and submitted purely via chansend into the terminal job channel — no keypress was sent to the Claude window.

❯ ZZAAA_chansend_insert

⏺ Bash(grep -rn "ZZAAA" . --include="*.lua" --include="*.sh" ... )
  ⎿  ---chansend_insert---
     ---chansend---

⏺ I searched the repo — ZZAAA_chansend_insert doesn't appear anywhere, and neither do
  chansend_insert or even chansend (the terminal code sends input a different way).
  ...

❯ What is 2+2? Reply with ONLY the digit, nothing else.

⏺ 4

The plugin debug log confirmed the resolution path: [ProtoInsert] bufnr=2 terminal_job_id=3 channel=3 followed by [ProtoSubmitCR] chan=3.