[FEATURE] Allow separate terminal width during diff vs idle

[mightreya]

Summary

Currently terminal.split_width_percentage controls the Claude terminal width both when idle and when a diff is open. This couples two preferences that, for me at least, want different values: I like a wide terminal (~50%) when chatting, but want it shrunk (~30%) while reviewing a diff so the diff has more room.

Proposal

Add an optional second config:

terminal = {
  split_width_percentage = 0.5,        -- idle width (existing)
  diff_split_width_percentage = 0.3,   -- new: width while a diff is active
}

Behavior:

• If diff_split_width_percentage is unset (default nil), keep current single-width behavior.
• If set: shrink the terminal to that percentage when a diff opens (in _create_diff_view_from_window), and restore to split_width_percentage when the diff closes (already handled in _cleanup_diff_state).

Context

I've been doing this locally via a monkey patch on _create_diff_view_from_window, and several other users with monkey-patched configs in the wild are doing the same thing. Worth promoting to a real config option.

Happy to open a PR if there's interest.

[ThomasK33]

Note

This triage report is AI-generated using Claude Code

Triage — separate terminal width during diff vs. idle

This has been triaged as a feature request, and the underlying need is a reasonable one. That said, a review of the current code, comparable tools, and this project's own history suggests the proposed config key may not be the best-shaped API for the need — exposing diff lifecycle events would likely serve this request (and several related ones) more durably. A working prototype of the proposed key is included below for evaluation.

What the code does today

• The Claude terminal is already re-resized to split_width_percentage when a diff opens (to counteract the wincmd = equalization) and again when it closes (in diff.lua, across the setup_new_buffer, display_terminal_in_new_tab, and _cleanup_diff_state paths). The request therefore only asks for the during-diff resize to target a different value — no new resize machinery is required.
• A new terminal.diff_split_width_percentage key would reach the diff module automatically, since terminal config is merged with vim.tbl_deep_extend.
• No User autocmd events are emitted anywhere in lua/ (verified: nvim_exec_autocmds is absent). Because of that, there is currently no event-based way to react to a diff opening or closing from a user config — which is why the behavior is presently obtained by monkey-patching the private _create_diff_view_from_window.

Is there an existing workaround?

Partially. diff_opts.open_in_new_tab = true together with diff_opts.hide_terminal_in_new_tab = true (added in #111) already maximizes diff space by moving the diff into its own tab and hiding the terminal. This does not match the exact request (a terminal that stays visible but narrower in the same tab), but it may satisfy the underlying goal and is available today with no code changes. Confirming whether that already covers the use case would be a sensible first step.

Prior art

Researched across the official clients and comparable Neovim plugins, with sources verified (see the collapsible section at the end):

Tool	Separate width during diff?	Diff/edit lifecycle events?	Relevance
VS Code / JetBrains (official Claude Code)	No width setting at all	—	No parity basis for an idle-vs-diff width; it is a Neovim-split-specific concern. The one upstream width ask (anthropics/claude-code#63813) requests a max-width cap, not a context-dependent width.
avante.nvim	One static windows.width; not resized for diffs	—	Most popular AI sidebar; no dual-width idiom to copy.
codecompanion.nvim	One static width, set once	Rich, documented CodeCompanion* events incl. …InlineStarted/Finished	Started/Finished bracketing an edit is the same open/close shape this request needs.
sindrets/diffview.nvim (same domain)	—	Both callbacks and DiffviewViewOpened/DiffviewViewClosed	Close template for ClaudeCodeDiffOpened/Closed; shows "both" is idiomatic.
folke/sidekick.nvim	review opens in a separate tab	SidekickNesShow/Hide/Done User events + data	Precedent for "emit events, let users resize however they like."
nickjvandyke/opencode.nvim	new tab for review	OpencodeEvent:* incl. session.diff	Second "expose events, react in config" precedent.
greggh/claude-code.nvim	open-time only; ratio-drift issue (#49) unresolved	none	The existing re-resize here is already more capable; illustrates the maintenance tail of width math.
aider.nvim	static layouts	none	Its docs warn that resizing a terminal split can reflow/truncate the embedded TUI's output — a reason to keep any automatic width change opt-in, relevant given the Snacks provider and the open report in #81.

A few takeaways:

• Firing User autocmds is the Neovim-idiomatic mechanism for plugin events and is used widely (Neovim core docs, oil.nvim, gitsigns.nvim, neogit, nvim-tree, lazy.nvim, snacks.nvim). This project currently emits none, so this is a genuine capability gap rather than duplication.
• Public monkey-patches of _create_diff_view_from_window exist for divergent purposes (e.g. floating-window diffs, external diff tooling, new-file buffer-naming fixes), which reinforces the value of a single supported hook over one narrow knob.

Relevant prior decisions in this project

Prior discussion in #28 ("Window ratio unexpectedly changes … during diff operations") noted that targeted per-window sizing can break multi-split layouts (e.g. panes collapsing toward ~17.5%), and the new-tab approach was preferred as the remedy — shipped in #111. A competing window-layout-restore change (#61) was closed without merging. Related terminal-width friction recurs but diverges in intent — #81 (Snacks width), #134 (re-wrap on resize), #204 (resize panes when toggled) — which tends to favor one generic seam over many narrow knobs.

Recommendation

1. Zero-code first response: confirm whether open_in_new_tab + hide_terminal_in_new_tab already covers the goal.
2. Preferred durable fix — emit User ClaudeCodeDiffOpened / ClaudeCodeDiffClosed with a data payload (provider, terminal/diff window ids, tab number, file path, is_new_file). This is the Neovim idiom, has same-domain precedent (diffview.nvim), would serve the various existing monkey-patch use cases at once, and would replace patching of a private (_-prefixed) function with a supported API.
3. Optional sugar — terminal.diff_split_width_percentage exactly as proposed. The prototype below shows it is small and fully backward-compatible (unset → byte-identical current behavior). It is reasonable to ship on top of events, or as a standalone quick win — though, as the sole solution, it is the narrowest option, applies only to non-floating splits, and (per the aider.nvim note) is best kept opt-in to avoid TUI reflow under Snacks.
4. Documentation / extension-seam gap: independent of the above, a supported hook plus docs would let users stop patching private internals.

One design caveat to resolve first: the built-in re-resize would overwrite a user's event handler (and the close-time restore would undo it). Whichever path is chosen, the built-in resize should be made conditional/suppressible when a handler — or the new key — is in play.

Open questions for discussion

• Event timing: should ClaudeCodeDiffOpened fire before the diff windows are created (so a handler can pre-size and avoid a visible reflow) or after (so window ids are available in the payload)? diffview/sidekick fire after the UI exists; a Pre/Post pair (as lazy.nvim does) is also an option.
• Payload contract: which fields belong in the event data (provider, terminal/diff window ids, tab number, old/new paths, is_new_file)? Settling this early avoids a later breaking change.
• Config-key scope (if added): default nil meaning "reuse split_width_percentage" (preserving today's behavior), ignored for floating terminals, and possibly gated for the Snacks provider given the TUI-truncation caution.
• Stability commitment: would the new events be treated as a supported, documented public API so users stop patching _create_diff_view_from_window, and is a richer subscribe()-style interface (the nvim-tree pattern) wanted later, or are User autocmds sufficient?
• Underlying goal: given the established new-tab precedent (feat: redesign diff view with horizontal layout and new tab options #111), does the use case actually require same-tab re-widthing, or would the new-tab options already suffice?

---

Exploratory prototype — terminal.diff_split_width_percentage (for evaluation; not a PR)

Built and validated locally on a throwaway branch (not pushed) to ground the feasibility of option (3). It adds the proposed key, routes the three diff-open resize sites through a small resolver while the two close/restore sites keep the idle width, validates input, and adds a type annotation. The full suite (mise run all) passes — 494/494 tests, lint and format clean — and behavior is unchanged when the key is unset.

diff --git a/lua/claudecode/diff.lua b/lua/claudecode/diff.lua
@@ -39,6 +39,34 @@ local function get_autocmd_group()
   return autocmd_group
 end
 
+---Resolve the terminal split-width percentage for the current context.
+---While a diff is active, an optional `terminal.diff_split_width_percentage`
+---(a number in the open interval (0, 1)) takes precedence so the Claude
+---terminal can shrink to give the diff more room. It falls back to the idle
+---`terminal.split_width_percentage`, then to the 0.30 default.
+---@param when "diff"|"idle" Whether a diff is currently active or being torn down
+---@return number percentage A width fraction in (0, 1)
+local function resolve_split_width_percentage(when)
+  local terminal_config = (config and config.terminal) or {}
+
+  local idle = terminal_config.split_width_percentage
+  if type(idle) ~= "number" or idle <= 0 or idle >= 1 then
+    idle = 0.30
+  end
+
+  if when == "diff" then
+    local diff_pct = terminal_config.diff_split_width_percentage
+    if type(diff_pct) == "number" and diff_pct > 0 and diff_pct < 1 then
+      return diff_pct
+    end
+  end
+
+  return idle
+end
+
+-- Exposed for testing the diff/idle width resolution logic.
+M._resolve_split_width_percentage = resolve_split_width_percentage
+
 ---Find a suitable main editor window to open diffs in.
 ---Excludes terminals, sidebars, and floating windows.
 ---@return number? win_id Window ID of the main editor window, or nil if not found
@@ -254,7 +282,8 @@ local function display_terminal_in_new_tab()
 
   local terminal_config = config.terminal or {}
   local split_side = terminal_config.split_side or "right"
-  local split_width = terminal_config.split_width_percentage or 0.30
+  -- A diff is opening in this new tab: use the diff-active width if configured.
+  local split_width = resolve_split_width_percentage("diff")
 
   -- Optionally hide the Claude terminal in the new tab for more review space
   local hide_in_new_tab = false
@@ -616,8 +645,8 @@ local function setup_new_buffer(
   end
 
   if terminal_win_in_new_tab and vim.api.nvim_win_is_valid(terminal_win_in_new_tab) then
-    local terminal_config = config.terminal or {}
-    local split_width = terminal_config.split_width_percentage or 0.30
+    -- Diff just opened in a new tab: use the diff-active width if configured.
+    local split_width = resolve_split_width_percentage("diff")
     local total_width = vim.o.columns
     local terminal_width = math.floor(total_width * split_width)
     vim.api.nvim_win_set_width(terminal_win_in_new_tab, terminal_width)
@@ -635,8 +664,8 @@ local function setup_new_buffer(
 
         -- Only resize split terminals. Floating terminals control their own sizing.
         if not is_floating then
-          local terminal_config = config.terminal or {}
-          local split_width = terminal_config.split_width_percentage or 0.30
+          -- Diff just opened in this tab: use the diff-active width if configured.
+          local split_width = resolve_split_width_percentage("diff")
           local total_width = vim.o.columns
           local terminal_width = math.floor(total_width * split_width)
           pcall(vim.api.nvim_win_set_width, terminal_win, terminal_width)
@@ -1049,8 +1078,8 @@ function M._cleanup_diff_state(tab_name, reason)
         local is_floating = win_config.relative and win_config.relative ~= ""
 
         if not is_floating then
-          local terminal_config = config.terminal or {}
-          local split_width = terminal_config.split_width_percentage or 0.30
+          -- Diff closed: restore the idle terminal width.
+          local split_width = resolve_split_width_percentage("idle")
           local total_width = vim.o.columns
           local terminal_width = math.floor(total_width * split_width)
           pcall(vim.api.nvim_win_set_width, terminal_win, terminal_width)
@@ -1086,8 +1115,8 @@ function M._cleanup_diff_state(tab_name, reason)
       local is_floating = win_config.relative and win_config.relative ~= ""
 
       if not is_floating then
-        local terminal_config = config.terminal or {}
-        local split_width = terminal_config.split_width_percentage or 0.30
+        -- Diff closed: restore the idle terminal width.
+        local split_width = resolve_split_width_percentage("idle")
         local total_width = vim.o.columns
         local terminal_width = math.floor(total_width * split_width)
         pcall(vim.api.nvim_win_set_width, terminal_win, terminal_width)
diff --git a/lua/claudecode/terminal.lua b/lua/claudecode/terminal.lua
@@ -10,6 +10,7 @@ local claudecode_server_module = require("claudecode.server.init")
 local defaults = {
   split_side = "right",
   split_width_percentage = 0.30,
+  diff_split_width_percentage = nil, -- optional terminal width while a diff is active; defaults to split_width_percentage
   provider = "auto",
   show_native_term_exit_tip = true,
   terminal_cmd = nil,
@@ -402,6 +403,15 @@ function M.setup(user_term_config, p_terminal_cmd, p_env)
           vim.log.levels.WARN
         )
       end
+    elseif k == "diff_split_width_percentage" then
+      if v == nil or (type(v) == "number" and v > 0 and v < 1) then
+        defaults.diff_split_width_percentage = v
+      else
+        vim.notify(
+          "claudecode.terminal.setup: Invalid value for diff_split_width_percentage: " .. tostring(v),
+          vim.log.levels.WARN
+        )
+      end
     elseif k == "provider" then
       if type(v) == "table" or v == "snacks" or v == "native" or v == "external" or v == "auto" or v == "none" then
         defaults.provider = v
diff --git a/lua/claudecode/types.lua b/lua/claudecode/types.lua
@@ -77,6 +77,7 @@
 ---@class ClaudeCodeTerminalConfig
 ---@field split_side ClaudeCodeSplitSide
 ---@field split_width_percentage number
+---@field diff_split_width_percentage number? -- optional terminal width while a diff is active; defaults to split_width_percentage
 ---@field provider ClaudeCodeTerminalProviderName|ClaudeCodeTerminalProvider
 ---@field show_native_term_exit_tip boolean
 ---@field terminal_cmd string?

Prototype test spec — tests/unit/diff_split_width_spec.lua

require("tests.busted_setup")

describe("Diff/idle terminal split width resolution", function()
  local diff = require("claudecode.diff")

  local function resolve(when)
    return diff._resolve_split_width_percentage(when)
  end

  it("uses split_width_percentage for both states when diff width is unset", function()
    diff.setup({ terminal = { split_width_percentage = 0.5 } })
    assert.are.equal(0.5, resolve("idle"))
    assert.are.equal(0.5, resolve("diff"))
  end)

  it("shrinks to diff_split_width_percentage while a diff is active, idle unchanged", function()
    diff.setup({ terminal = { split_width_percentage = 0.5, diff_split_width_percentage = 0.3 } })
    assert.are.equal(0.5, resolve("idle"))
    assert.are.equal(0.3, resolve("diff"))
  end)

  it("falls back to the 0.30 default when no widths are configured", function()
    diff.setup({ terminal = {} })
    assert.are.equal(0.30, resolve("idle"))
    assert.are.equal(0.30, resolve("diff"))
  end)

  it("ignores an out-of-range diff width and falls back to the idle width", function()
    diff.setup({ terminal = { split_width_percentage = 0.5, diff_split_width_percentage = 2.0 } })
    assert.are.equal(0.5, resolve("diff"))
  end)

  it("ignores a non-number diff width and falls back to the idle width", function()
    diff.setup({ terminal = { split_width_percentage = 0.4, diff_split_width_percentage = "wide" } })
    assert.are.equal(0.4, resolve("diff"))
  end)

  it("allows a diff width wider than the idle width", function()
    diff.setup({ terminal = { split_width_percentage = 0.3, diff_split_width_percentage = 0.6 } })
    assert.are.equal(0.3, resolve("idle"))
    assert.are.equal(0.6, resolve("diff"))
  end)
end)

Verified prior-art sources

Official Claude Code clients

• VS Code extension settings: https://code.claude.com/docs/en/vs-code
• Upstream max-width-cap request: [FEATURE] VS Code extension: cap chat panel max-width for readability on wide displays anthropics/claude-code#63813
• JetBrains plugin: https://code.claude.com/docs/en/jetbrains

Comparable Neovim plugins

• avante.nvim: lua/avante/config.lua, lua/avante/sidebar.lua, lua/avante/diff.lua (https://github.com/yetone/avante.nvim)
• codecompanion.nvim config: https://github.com/olimorris/codecompanion.nvim/blob/main/lua/codecompanion/config.lua
• codecompanion.nvim events: https://github.com/olimorris/codecompanion.nvim/blob/main/doc/usage/events.md
• diffview.nvim docs (callbacks + User events): https://github.com/sindrets/diffview.nvim/blob/main/doc/diffview.txt
• sidekick.nvim NES events: lua/sidekick/nes/ui.lua, lua/sidekick/nes/init.lua (https://github.com/folke/sidekick.nvim)
• opencode.nvim events: https://github.com/nickjvandyke/opencode.nvim/blob/main/README.md
• greggh/claude-code.nvim terminal + ratio-drift issue: https://github.com/greggh/claude-code.nvim/blob/main/lua/claude-code/terminal.lua , [BUG] Claude Code split doesn't maintain ratio after creating/removing split from the other/nvim window greggh/claude-code.nvim#49
• aider.nvim (TUI-truncation note): https://github.com/joshuavial/aider.nvim

Neovim User autocmd idiom

• Core docs: https://github.com/neovim/neovim/blob/master/runtime/doc/autocmd.txt
• Examples: oil.nvim, gitsigns.nvim, lazy.nvim (https://lazy.folke.io/usage), snacks.nvim