feat: enhance MCP tools with VS Code compatibility and success fields

Change-Id: Iddb033256d1c8093e871f3a303a95e4df35ef9aa
Signed-off-by: Thomas Kosiewski <[email protected]>

Author: ThomasK33

CLAUDE.md

@@ -80,6 +80,7 @@ The WebSocket server implements secure authentication using:
 - `saveDocument` - Saves document with detailed success/failure reporting
 - `getWorkspaceFolders` - Gets workspace folder information
 - `closeAllDiffTabs` - Closes all diff-related tabs and windows
+- `getDiagnostics` - Gets language diagnostics (errors, warnings) from the editor
 
 **Internal Tools** (not exposed via MCP):
 
@@ -108,7 +109,7 @@ The WebSocket server implements secure authentication using:
 
 claudecode.nvim implements **100% feature parity** with Anthropic's official VS Code extension:
 
-- **Identical Tool Set**: All 12 VS Code tools implemented
+- **Identical Tool Set**: All 10 VS Code tools implemented
 - **Compatible Formats**: Output structures match VS Code extension exactly
 - **Behavioral Consistency**: Same parameter handling and response patterns
 - **Error Compatibility**: Matching error codes and messages

lua/claudecode/tools/get_current_selection.lua

@@ -9,6 +9,23 @@ local schema = {
   },
 }
 
+--- Helper function to safely encode data as JSON with error handling.
+-- @param data table The data to encode as JSON.
+-- @param error_context string A description of what failed for error messages.
+-- @return string The JSON-encoded string.
+-- @error table A table with code, message, and data for JSON-RPC error if encoding fails.
+local function safe_json_encode(data, error_context)
+  local ok, encoded = pcall(vim.json.encode, data, { indent = 2 })
+  if not ok then
+    error({
+      code = -32000,
+      message = "Internal server error",
+      data = "Failed to encode " .. error_context .. ": " .. tostring(encoded),
+    })
+  end
+  return encoded
+end
+
 --- Handles the getCurrentSelection tool invocation.
 -- Gets the current text selection in the editor.
 -- @param params table The input parameters for the tool (currently unused).
@@ -23,13 +40,33 @@ local function handler(_params) -- Prefix unused params with underscore
   local selection = selection_module.get_latest_selection()
 
   if not selection then
-    -- Consider if "no selection" is an error or a valid state returning empty/specific data.
-    -- For now, returning an empty object or specific structure might be better than an error.
-    -- Let's assume it's valid to have no selection and return a structure indicating that.
+    -- Check if there's an active editor/buffer
+    local current_buf = vim.api.nvim_get_current_buf()
+    local buf_name = vim.api.nvim_buf_get_name(current_buf)
+
+    if not buf_name or buf_name == "" then
+      -- No active editor case - match VS Code format
+      local no_editor_response = {
+        success = false,
+        message = "No active editor found",
+      }
+
+      return {
+        content = {
+          {
+            type = "text",
+            text = safe_json_encode(no_editor_response, "no editor response"),
+          },
+        },
+      }
+    end
+
+    -- Valid buffer but no selection - return cursor position with success field
     local empty_selection = {
+      success = true,
       text = "",
-      filePath = vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
-      fileUrl = "file://" .. vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
+      filePath = buf_name,
+      fileUrl = "file://" .. buf_name,
       selection = {
         start = { line = 0, character = 0 },
         ["end"] = { line = 0, character = 0 },
@@ -42,18 +79,21 @@ local function handler(_params) -- Prefix unused params with underscore
       content = {
         {
           type = "text",
-          text = vim.json.encode(empty_selection, { indent = 2 }),
+          text = safe_json_encode(empty_selection, "empty selection"),
         },
       },
     }
   end
 
+  -- Add success field to existing selection data
+  local selection_with_success = vim.tbl_extend("force", selection, { success = true })
+
   -- Return MCP-compliant format with JSON-stringified selection data
   return {
     content = {
       {
         type = "text",
-        text = vim.json.encode(selection, { indent = 2 }),
+        text = safe_json_encode(selection_with_success, "selection"),
       },
     },
   }

lua/claudecode/tools/get_open_editors.lua

@@ -17,6 +17,14 @@ local function handler(_params) -- Prefix unused params with underscore
   local tabs = {}
   local buffers = vim.api.nvim_list_bufs()
   local current_buf = vim.api.nvim_get_current_buf()
+  local current_tabpage = vim.api.nvim_get_current_tabpage()
+
+  -- Get selection for active editor if available
+  local active_selection = nil
+  local selection_module_ok, selection_module = pcall(require, "claudecode.selection")
+  if selection_module_ok then
+    active_selection = selection_module.get_latest_selection()
+  end
 
   for _, bufnr in ipairs(buffers) do
     -- Only include loaded, listed buffers with a file path
@@ -25,21 +33,70 @@ local function handler(_params) -- Prefix unused params with underscore
 
       if file_path and file_path ~= "" then
         -- Get the filename for the label
-        local label = vim.fn.fnamemodify(file_path, ":t")
+        local ok_label, label = pcall(vim.fn.fnamemodify, file_path, ":t")
+        if not ok_label then
+          label = file_path -- Fallback to full path
+        end
 
         -- Get language ID (filetype)
-        local language_id = vim.api.nvim_buf_get_option(bufnr, "filetype")
-        if language_id == "" then
+        local ok_lang, language_id = pcall(vim.api.nvim_buf_get_option, bufnr, "filetype")
+        if not ok_lang or language_id == nil or language_id == "" then
           language_id = "plaintext"
         end
 
-        table.insert(tabs, {
+        -- Get line count
+        local line_count = 0
+        local ok_lines, lines_result = pcall(vim.api.nvim_buf_line_count, bufnr)
+        if ok_lines then
+          line_count = lines_result
+        end
+
+        -- Check if untitled (no file path or special buffer)
+        local is_untitled = (
+          not file_path
+          or file_path == ""
+          or string.match(file_path, "^%s*$") ~= nil
+          or string.match(file_path, "^term://") ~= nil
+          or string.match(file_path, "^%[.*%]$") ~= nil
+        )
+
+        -- Get tabpage info for this buffer
+        -- For simplicity, use current tabpage as the "group" for all buffers
+        -- In a more complex implementation, we could track which tabpage last showed each buffer
+        local group_index = current_tabpage - 1 -- 0-based
+        local view_column = current_tabpage -- 1-based
+        local is_group_active = true -- Current tabpage is always active
+
+        -- Build tab object with all VS Code fields
+        local tab = {
           uri = "file://" .. file_path,
           isActive = bufnr == current_buf,
+          isPinned = false, -- Neovim doesn't have pinned tabs
+          isPreview = false, -- Neovim doesn't have preview tabs
+          isDirty = (function()
+            local ok, modified = pcall(vim.api.nvim_buf_get_option, bufnr, "modified")
+            return ok and modified or false
+          end)(),
           label = label,
+          groupIndex = group_index,
+          viewColumn = view_column,
+          isGroupActive = is_group_active,
+          fileName = file_path,
           languageId = language_id,
-          isDirty = vim.api.nvim_buf_get_option(bufnr, "modified"),
-        })
+          lineCount = line_count,
+          isUntitled = is_untitled,
+        }
+
+        -- Add selection info for active editor
+        if bufnr == current_buf and active_selection and active_selection.selection then
+          tab.selection = {
+            start = active_selection.selection.start,
+            ["end"] = active_selection.selection["end"],
+            isReversed = false, -- Neovim doesn't track reversed selections like VS Code
+          }
+        end
+
+        table.insert(tabs, tab)
       end
     end
   end

lua/claudecode/tools/save_document.lua

@@ -24,7 +24,11 @@ local schema = {
 -- @error table A table with code, message, and data for JSON-RPC error if failed.
 local function handler(params)
   if not params.filePath then
-    error({ code = -32602, message = "Invalid params", data = "Missing filePath parameter" })
+    error({
+      code = -32602,
+      message = "Invalid params",
+      data = "Missing filePath parameter",
+    })
   end
 
   local bufnr = vim.fn.bufnr(params.filePath)

tests/busted_setup.lua

@@ -113,15 +113,13 @@ _G.json_encode = function(data)
   if type(data) == "table" then
     local parts = {}
     local is_array = true
-    local array_index = 1
 
-    -- Check if it's an array or object
+    -- Check if it's an array (all numeric, positive keys) or an object
     for k, _ in pairs(data) do
-      if type(k) ~= "number" or k ~= array_index then
+      if type(k) ~= "number" or k <= 0 or math.floor(k) ~= k then
         is_array = false
         break
       end
-      array_index = array_index + 1
     end
 
     if is_array then

tests/mocks/vim.lua

@@ -564,6 +564,22 @@ local vim = {
     },
   },
 
+  -- Add tbl_extend function for compatibility
+  tbl_extend = function(behavior, ...)
+    local tables = { ... }
+    local result = {}
+
+    for _, tbl in ipairs(tables) do
+      for k, v in pairs(tbl) do
+        if behavior == "force" or result[k] == nil then
+          result[k] = v
+        end
+      end
+    end
+
+    return result
+  end,
+
   notify = function(msg, level, opts)
     -- Store the last notification for test assertions
     vim._last_notify = {

tests/unit/tools/get_current_selection_spec.lua

@@ -57,6 +57,7 @@ describe("Tool: get_current_selection", function()
     expect(result.content[1].type).to_be("text")
 
     local parsed_result = require("tests.busted_setup").json_decode(result.content[1].text)
+    expect(parsed_result.success).to_be_true() -- New success field
     expect(parsed_result.text).to_be("")
     expect(parsed_result.filePath).to_be("/current/file.lua")
     expect(parsed_result.selection.isEmpty).to_be_true()
@@ -88,10 +89,38 @@ describe("Tool: get_current_selection", function()
     expect(result.content[1].type).to_be("text")
 
     local parsed_result = require("tests.busted_setup").json_decode(result.content[1].text)
-    assert.are.same(mock_sel_data, parsed_result) -- Should return the exact data as JSON
+    -- Should return the selection data with success field added
+    local expected_result = vim.tbl_extend("force", mock_sel_data, { success = true })
+    assert.are.same(expected_result, parsed_result)
     assert.spy(mock_selection_module.get_latest_selection).was_called()
   end)
 
+  it("should return error format when no active editor is found", function()
+    mock_selection_module.get_latest_selection = spy.new(function()
+      return nil
+    end)
+
+    -- Mock empty buffer name to simulate no active editor
+    _G.vim.api.nvim_buf_get_name = spy.new(function()
+      return ""
+    end)
+
+    local success, result = pcall(get_current_selection_handler, {})
+    expect(success).to_be_true()
+    expect(result).to_be_table()
+    expect(result.content).to_be_table()
+    expect(result.content[1]).to_be_table()
+    expect(result.content[1].type).to_be("text")
+
+    local parsed_result = require("tests.busted_setup").json_decode(result.content[1].text)
+    expect(parsed_result.success).to_be_false()
+    expect(parsed_result.message).to_be("No active editor found")
+    -- Should not have other fields when success is false
+    expect(parsed_result.text).to_be_nil()
+    expect(parsed_result.filePath).to_be_nil()
+    expect(parsed_result.selection).to_be_nil()
+  end)
+
   it("should handle pcall failure when requiring selection module", function()
     -- Simulate require failing
     package.loaded["claudecode.selection"] = nil -- Ensure it's not cached

tests/unit/tools/get_latest_selection_spec.lua

@@ -94,7 +94,7 @@ describe("Tool: get_latest_selection", function()
     expect(success).to_be_false()
     expect(err).to_be_table()
     expect(err.code).to_be(-32000)
-    assert_contains(err.message, "Internal server error")
-    assert_contains(err.data, "Failed to load selection module")
+    expect(err.message).to_be("Internal server error")
+    expect(err.data).to_be("Failed to load selection module")
   end)
 end)