feat: add ClaudeCodeDiffAccept and ClaudeCodeDiffDeny user commands

- Add ClaudeCodeDiffAccept and ClaudeCodeDiffDeny user commands to init.lua
- Implement accept_current_diff() and deny_current_diff() functions in diff.lua
- Refactor keymaps to use new commands instead of inline functions
- Store diff context in buffer variables for command access
- Update README.md with new commands and customization examples
- Maintain backward compatibility with existing <leader>da and <leader>dq keymaps

Resolves issue #44 by allowing users to customize diff keymaps without conflicts

Co-authored-by: ThomasK33 <[email protected]>
Signed-off-by: Thomas Kosiewski <[email protected]>

Author: blink-so[bot]

README.md

@@ -88,6 +88,8 @@ That's it! For more configuration options, see [Advanced Setup](#advanced-setup)
 - `:ClaudeCodeSend` - Send current visual selection to Claude, or add files from tree explorer
 - `:ClaudeCodeTreeAdd` - Add selected file(s) from tree explorer to Claude context (also available via ClaudeCodeSend)
 - `:ClaudeCodeAdd <file-path> [start-line] [end-line]` - Add a specific file or directory to Claude context by path with optional line range
+- `:ClaudeCodeDiffAccept` - Accept the current diff changes (equivalent to `<leader>da`)
+- `:ClaudeCodeDiffDeny` - Deny/reject the current diff changes (equivalent to `<leader>dq`)
 
 ### Toggle Behavior
 
@@ -155,6 +157,18 @@ When you reject changes, the diff view closes and the original file remains unch
 
 You can also navigate to the Claude Code terminal window and accept or reject diffs directly from within Claude's interface. This provides an alternative way to manage diffs without using the Neovim-specific keymaps.
 
+### Customizing Diff Keymaps
+
+The default keymaps (`<leader>da` and `<leader>dq`) can be customized by remapping them to the underlying commands:
+
+```lua
+-- Example: Use different keymaps for diff handling
+vim.keymap.set('n', '<leader>ya', '<cmd>ClaudeCodeDiffAccept<cr>', { desc = 'Accept diff' })
+vim.keymap.set('n', '<leader>yn', '<cmd>ClaudeCodeDiffDeny<cr>', { desc = 'Deny diff' })
+```
+
+The commands `ClaudeCodeDiffAccept` and `ClaudeCodeDiffDeny` work only in diff buffers created by the plugin and will show a warning if used elsewhere.
+
 ### How It Works
 
 The plugin uses a signal-based approach where accepting or rejecting a diff sends a message to Claude Code rather than directly modifying files. This ensures consistency and allows Claude Code to handle the actual file operations while the plugin manages the user interface and buffer reloading.

lua/claudecode/diff.lua

@@ -578,23 +578,16 @@ function M._create_diff_view_from_window(target_window, old_file_path, new_buffe
   vim.cmd("wincmd =")
   vim.api.nvim_set_current_win(new_win)
 
-  local keymap_opts = { buffer = new_buffer, silent = true }
-
-  vim.keymap.set("n", "<leader>da", function()
-    M._resolve_diff_as_saved(tab_name, new_buffer)
-  end, keymap_opts)
+  -- Store diff context in buffer variables for user commands
+  vim.b[new_buffer].claudecode_diff_tab_name = tab_name
+  vim.b[new_buffer].claudecode_diff_new_win = new_win
+  vim.b[new_buffer].claudecode_diff_target_win = target_window
 
-  vim.keymap.set("n", "<leader>dq", function()
-    if vim.api.nvim_win_is_valid(new_win) then
-      vim.api.nvim_win_close(new_win, true)
-    end
-    if vim.api.nvim_win_is_valid(target_window) then
-      vim.api.nvim_set_current_win(target_window)
-      vim.cmd("diffoff")
-    end
+  local keymap_opts = { buffer = new_buffer, silent = true }
 
-    M._resolve_diff_as_rejected(tab_name)
-  end, keymap_opts)
+  -- Use the new user commands instead of inline functions
+  vim.keymap.set("n", "<leader>da", "<cmd>ClaudeCodeDiffAccept<cr>", keymap_opts)
+  vim.keymap.set("n", "<leader>dq", "<cmd>ClaudeCodeDiffDeny<cr>", keymap_opts)
 
   -- Return window information for later storage
   return {
@@ -899,4 +892,43 @@ function M.reload_file_buffers_manual(file_path, original_cursor_pos)
   return reload_file_buffers(file_path, original_cursor_pos)
 end
 
+--- Accept the current diff (user command version)
+-- This function reads the diff context from buffer variables
+function M.accept_current_diff()
+  local current_buffer = vim.api.nvim_get_current_buf()
+  local tab_name = vim.b[current_buffer].claudecode_diff_tab_name
+
+  if not tab_name then
+    vim.notify("No active diff found in current buffer", vim.log.levels.WARN)
+    return
+  end
+
+  M._resolve_diff_as_saved(tab_name, current_buffer)
+end
+
+--- Deny/reject the current diff (user command version)
+-- This function reads the diff context from buffer variables
+function M.deny_current_diff()
+  local current_buffer = vim.api.nvim_get_current_buf()
+  local tab_name = vim.b[current_buffer].claudecode_diff_tab_name
+  local new_win = vim.b[current_buffer].claudecode_diff_new_win
+  local target_window = vim.b[current_buffer].claudecode_diff_target_win
+
+  if not tab_name then
+    vim.notify("No active diff found in current buffer", vim.log.levels.WARN)
+    return
+  end
+
+  -- Close windows and clean up (same logic as the original keymap)
+  if new_win and vim.api.nvim_win_is_valid(new_win) then
+    vim.api.nvim_win_close(new_win, true)
+  end
+  if target_window and vim.api.nvim_win_is_valid(target_window) then
+    vim.api.nvim_set_current_win(target_window)
+    vim.cmd("diffoff")
+  end
+
+  M._resolve_diff_as_rejected(tab_name)
+end
+
 return M

lua/claudecode/init.lua

@@ -880,6 +880,21 @@ function M._create_commands()
       "Terminal module not found. Terminal commands (ClaudeCode, ClaudeCodeOpen, ClaudeCodeClose) not registered."
     )
   end
+
+  -- Diff management commands
+  vim.api.nvim_create_user_command("ClaudeCodeDiffAccept", function()
+    local diff = require("claudecode.diff")
+    diff.accept_current_diff()
+  end, {
+    desc = "Accept the current diff changes",
+  })
+
+  vim.api.nvim_create_user_command("ClaudeCodeDiffDeny", function()
+    local diff = require("claudecode.diff")
+    diff.deny_current_diff()
+  end, {
+    desc = "Deny/reject the current diff changes",
+  })
 end
 
 --- Get version information