fix(range-selection): support :'<,'>ClaudeCodeSend and stabilize tests

Adds range-selection handling via marks, fixes visual selection fallback, and guards
terminal.setup call for tests. Resolves #25.

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

Author: blink-so[bot]

lua/claudecode/init.lua

@@ -102,10 +102,11 @@ function M.setup(opts)
   -- even if terminal_opts (for split_side etc.) are not provided.
   local terminal_setup_ok, terminal_module = pcall(require, "claudecode.terminal")
   if terminal_setup_ok then
-    -- terminal_opts might be nil if user only configured top-level terminal_cmd
-    -- and not specific terminal appearance options.
-    -- The terminal.setup function handles nil for its first argument.
-    terminal_module.setup(terminal_opts, M.state.config.terminal_cmd)
+    -- Guard in case tests or user replace the module with a minimal stub without `setup`.
+    if type(terminal_module.setup) == "function" then
+      -- terminal_opts might be nil, which the setup function should handle gracefully.
+      terminal_module.setup(terminal_opts, M.state.config.terminal_cmd)
+    end
   else
     logger.error("init", "Failed to load claudecode.terminal module for setup.")
   end
@@ -403,6 +404,7 @@ function M._create_commands()
       return
     end
 
+
     local current_ft = vim.bo.filetype
     local current_bufname = vim.api.nvim_buf_get_name(0)
 
@@ -434,7 +436,12 @@ function M._create_commands()
 
     local selection_module_ok, selection_module = pcall(require, "claudecode.selection")
     if selection_module_ok then
-      local sent_successfully = selection_module.send_at_mention_for_visual_selection()
+      -- Pass range information if available (for :'<,'> commands)
+      local line1, line2 = nil, nil
+      if opts and opts.range and opts.range > 0 then
+        line1, line2 = opts.line1, opts.line2
+      end
+      local sent_successfully = selection_module.send_at_mention_for_visual_selection(line1, line2)
       if sent_successfully then
         local terminal_ok, terminal = pcall(require, "claudecode.terminal")
         if terminal_ok then

lua/claudecode/selection.lua

@@ -573,25 +573,91 @@ function M.send_current_selection()
   vim.api.nvim_echo({ { "Selection sent to Claude", "Normal" } }, false, {})
 end
 
+--- Gets selection from range marks (e.g., when using :'<,'> commands)
+-- @param line1 number The start line (1-indexed)
+-- @param line2 number The end line (1-indexed)
+-- @return table|nil A table containing selection text, file path, URL, and
+--                   start/end positions, or nil if invalid range
+function M.get_range_selection(line1, line2)
+  if not line1 or not line2 or line1 < 1 or line2 < 1 or line1 > line2 then
+    return nil
+  end
+
+  local current_buf = vim.api.nvim_get_current_buf()
+  local file_path = vim.api.nvim_buf_get_name(current_buf)
+
+  -- Get the total number of lines in the buffer
+  local total_lines = vim.api.nvim_buf_line_count(current_buf)
+
+  -- Ensure line2 doesn't exceed buffer bounds
+  if line2 > total_lines then
+    line2 = total_lines
+  end
+
+  local lines_content = vim.api.nvim_buf_get_lines(
+    current_buf,
+    line1 - 1, -- Convert to 0-indexed
+    line2, -- nvim_buf_get_lines end is exclusive
+    false
+  )
+
+  if #lines_content == 0 then
+    return nil
+  end
+
+  local final_text = table.concat(lines_content, "\n")
+
+  -- For range selections, we treat them as linewise
+  local lsp_start_line = line1 - 1 -- Convert to 0-indexed
+  local lsp_end_line = line2 - 1
+  local lsp_start_char = 0
+  local lsp_end_char = #lines_content[#lines_content]
+
+  return {
+    text = final_text or "",
+    filePath = file_path,
+    fileUrl = "file://" .. file_path,
+    selection = {
+      start = { line = lsp_start_line, character = lsp_start_char },
+      ["end"] = { line = lsp_end_line, character = lsp_end_char },
+      isEmpty = (not final_text or #final_text == 0),
+    },
+  }
+end
+
 --- Sends an at_mentioned notification for the current visual selection.
-function M.send_at_mention_for_visual_selection()
+-- @param line1 number|nil Optional start line for range-based selection
+-- @param line2 number|nil Optional end line for range-based selection
+function M.send_at_mention_for_visual_selection(line1, line2)
   if not M.state.tracking_enabled or not M.server then
     logger.error("selection", "Claude Code is not running or server not available for send_at_mention.")
     return false
   end
 
-  local sel_to_send = M.state.latest_selection
+  local sel_to_send
 
-  if not sel_to_send or sel_to_send.selection.isEmpty then
-    -- Fallback: try to get current visual selection directly.
-    -- This helps if latest_selection was demoted or command was too fast.
-    local current_visual = M.get_visual_selection()
-    if current_visual and not current_visual.selection.isEmpty then
-      sel_to_send = current_visual
-    else
-      logger.warn("selection", "No visual selection to send as at-mention.")
+  -- If range parameters are provided, use them (for :'<,'> commands)
+  if line1 and line2 then
+    sel_to_send = M.get_range_selection(line1, line2)
+    if not sel_to_send or sel_to_send.selection.isEmpty then
+      logger.warn("selection", "Invalid range selection to send as at-mention.")
       return false
     end
+  else
+    -- Use existing logic for visual mode or tracked selection
+    sel_to_send = M.state.latest_selection
+
+    if not sel_to_send or sel_to_send.selection.isEmpty then
+      -- Fallback: try to get current visual selection directly.
+      -- This helps if latest_selection was demoted or command was too fast.
+      local current_visual = M.get_visual_selection()
+      if current_visual and not current_visual.selection.isEmpty then
+        sel_to_send = current_visual
+      else
+        logger.warn("selection", "No visual selection to send as at-mention.")
+        return false
+      end
+    end
   end
 
   -- Sanity check: ensure the selection is for the current buffer

tests/selection_test.lua

@@ -454,3 +454,177 @@ describe("Selection module", function()
     assert(selection.has_selection_changed(new_selection_diff_pos) == true)
   end)
 end)
+
+-- Tests for range selection functionality (fix for issue #25)
+describe("Range Selection Tests", function()
+  local selection
+
+  before_each(function()
+    -- Reset vim state
+    _G.vim._buffers = {
+      [1] = {
+        name = "/test/file.lua",
+        lines = {
+          "line 1",
+          "line 2",
+          "line 3",
+          "line 4",
+          "line 5",
+          "line 6",
+          "line 7",
+          "line 8",
+          "line 9",
+          "line 10"
+        }
+      }
+    }
+    _G.vim._windows = {
+      [1] = {
+        cursor = { 1, 0 }
+      }
+    }
+    _G.vim._current_mode = "n"
+
+    -- Add nvim_buf_line_count function
+    _G.vim.api.nvim_buf_line_count = function(bufnr)
+      return _G.vim._buffers[bufnr] and #_G.vim._buffers[bufnr].lines or 0
+    end
+
+    -- Reload the selection module
+    package.loaded["claudecode.selection"] = nil
+    selection = require("claudecode.selection")
+  end)
+
+  describe("get_range_selection", function()
+    it("should return valid selection for valid range", function()
+      local result = selection.get_range_selection(2, 4)
+
+      assert(result ~= nil)
+      assert(result.text == "line 2\nline 3\nline 4")
+      assert(result.filePath == "/test/file.lua")
+      assert(result.fileUrl == "file:///test/file.lua")
+      assert(result.selection.start.line == 1) -- 0-indexed
+      assert(result.selection.start.character == 0)
+      assert(result.selection["end"].line == 3) -- 0-indexed
+      assert(result.selection["end"].character == 6) -- length of "line 4"
+      assert(result.selection.isEmpty == false)
+    end)
+
+    it("should return valid selection for single line range", function()
+      local result = selection.get_range_selection(3, 3)
+
+      assert(result ~= nil)
+      assert(result.text == "line 3")
+      assert(result.selection.start.line == 2) -- 0-indexed
+      assert(result.selection["end"].line == 2) -- 0-indexed
+      assert(result.selection.isEmpty == false)
+    end)
+
+    it("should handle range that exceeds buffer bounds", function()
+      local result = selection.get_range_selection(8, 15) -- buffer only has 10 lines
+
+      assert(result ~= nil)
+      assert(result.text == "line 8\nline 9\nline 10")
+      assert(result.selection.start.line == 7) -- 0-indexed
+      assert(result.selection["end"].line == 9) -- 0-indexed, clamped to buffer size
+    end)
+
+    it("should return nil for invalid range (line1 > line2)", function()
+      local result = selection.get_range_selection(5, 3)
+      assert(result == nil)
+    end)
+
+    it("should return nil for invalid range (line1 < 1)", function()
+      local result = selection.get_range_selection(0, 3)
+      assert(result == nil)
+    end)
+
+    it("should return nil for invalid range (line2 < 1)", function()
+      local result = selection.get_range_selection(2, 0)
+      assert(result == nil)
+    end)
+
+    it("should return nil for nil parameters", function()
+      local result1 = selection.get_range_selection(nil, 3)
+      local result2 = selection.get_range_selection(2, nil)
+      local result3 = selection.get_range_selection(nil, nil)
+
+      assert(result1 == nil)
+      assert(result2 == nil)
+      assert(result3 == nil)
+    end)
+
+    it("should handle empty buffer", function()
+      _G.vim._buffers[1].lines = {}
+      local result = selection.get_range_selection(1, 1)
+      assert(result == nil)
+    end)
+  end)
+
+  describe("send_at_mention_for_visual_selection with range", function()
+    local mock_server
+
+    before_each(function()
+      mock_server = {
+        broadcast = function(event, params)
+          mock_server.last_broadcast = {
+            event = event,
+            params = params
+          }
+          return true
+        end
+      }
+
+      selection.state.tracking_enabled = true
+      selection.server = mock_server
+    end)
+
+    it("should send range selection successfully", function()
+      local result = selection.send_at_mention_for_visual_selection(2, 4)
+
+      assert(result == true)
+      assert(mock_server.last_broadcast ~= nil)
+      assert(mock_server.last_broadcast.event == "at_mentioned")
+      assert(mock_server.last_broadcast.params.filePath == "/test/file.lua")
+      assert(mock_server.last_broadcast.params.lineStart == 1) -- 0-indexed
+      assert(mock_server.last_broadcast.params.lineEnd == 3) -- 0-indexed
+    end)
+
+    it("should fail for invalid range", function()
+      local result = selection.send_at_mention_for_visual_selection(5, 3)
+      assert(result == false)
+    end)
+
+    it("should fall back to existing logic when no range provided", function()
+      -- Set up a tracked selection
+      selection.state.latest_selection = {
+        text = "tracked text",
+        filePath = "/test/file.lua",
+        fileUrl = "file:///test/file.lua",
+        selection = {
+          start = { line = 0, character = 0 },
+          ["end"] = { line = 0, character = 12 },
+          isEmpty = false
+        }
+      }
+
+      local result = selection.send_at_mention_for_visual_selection()
+
+      assert(result == true)
+      assert(mock_server.last_broadcast.params.lineStart == 0)
+      assert(mock_server.last_broadcast.params.lineEnd == 0)
+    end)
+
+    it("should fail when server is not available", function()
+      selection.server = nil
+      local result = selection.send_at_mention_for_visual_selection(2, 4)
+      assert(result == false)
+    end)
+
+    it("should fail when tracking is disabled", function()
+      selection.state.tracking_enabled = false
+      local result = selection.send_at_mention_for_visual_selection(2, 4)
+      assert(result == false)
+    end)
+  end)
+end)