Add automatic kit scanning functionality

lua/cmake-tools/const.lua

@@ -21,7 +21,7 @@ local const = {
     -- none:      this will make this option ignored
     target = vim.loop.cwd(), -- path to directory, this is used only if action == "soft_link" or action == "copy"
   },
-  cmake_kits_path = nil, -- this is used to specify global cmake kits path, see CMakeKits for detailed usage
+  cmake_kits_path = "~/.config/cmake-tools/", -- this is used to specify global cmake kits path, see CMakeKits for detailed usage
   cmake_variants_message = {
     short = { show = true }, -- whether to show short message
     long = { show = true, max_length = 40 }, -- whether to show long message

lua/cmake-tools/init.lua

@@ -5,6 +5,7 @@ local const = require("cmake-tools.const")
 local Config = require("cmake-tools.config")
 local variants = require("cmake-tools.variants")
 local kits = require("cmake-tools.kits")
+local scanner = require("cmake-tools.scanner")
 local Presets = require("cmake-tools.presets")
 local log = require("cmake-tools.log")
 local hints = require("cmake-tools.hints")
@@ -205,6 +206,9 @@ function cmake.generate(opt, callback)
   -- if exists cmake-kits.json, kit is used to set
   -- environmental variables and args.
   local kits_config = kits.parse(const.cmake_kits_path, config.cwd)
+  if not kits_config then
+    kits_config = scanner.scan_for_kits()
+  end
   if kits_config and not config.kit then
     return cmake.select_kit(function(result)
       if not result:is_ok() then
@@ -742,6 +746,29 @@ function cmake.select_build_type(callback)
   )
 end
 
+function cmake.scan_for_kits(callback)
+  callback = type(callback) == "function" and callback
+    or function(result)
+      if result:is_ok() then
+        cmake.generate({ bang = false, fargs = {} }, nil)
+      end
+    end
+  if check_active_job_and_notify(callback) then
+    return
+  end
+
+  if get_cmake_configuration_or_notify(callback) == nil then
+    return
+  end
+
+  local kits = scanner.scan_for_kits()
+  if kits then
+    callback(Result:new(Types.SUCCESS, nil, nil))
+  else
+    callback(Result:new_error(Types.CANNOT_FIND_CMAKE_KITS, "Cannot find CMakeKits file"))
+  end
+end
+
 function cmake.select_kit(callback)
   callback = type(callback) == "function" and callback
     or function(result)

lua/cmake-tools/scanner.lua

@@ -0,0 +1,211 @@
+local scanner = {}
+-- Configuration
+scanner.HOME = os.getenv("HOME") or os.getenv("USERPROFILE")
+scanner.KITS_FILE = scanner.HOME .. "/.config/cmake-tools/cmake-kits.json"
+
+--Helper functions
+-- Simple JSON encoder
+function scanner.json_encode(obj, indent)
+  indent = indent or 0
+  local spaces = string.rep("  ", indent)
+
+  if type(obj) == "table" then
+    local is_array = #obj > 0
+    local result = "{\n"
+    local first = true
+
+    for k, v in pairs(obj) do
+      if not first then
+        result = result .. ",\n"
+      end
+      first = false
+
+      if is_array then
+        result = result .. spaces .. "  " .. scanner.json_encode(v, indent + 1)
+      else
+        result = result .. spaces .. '  "' .. k .. '": ' .. scanner.json_encode(v, indent + 1)
+      end
+    end
+
+    return result .. "\n" .. spaces .. "}"
+  elseif type(obj) == "string" then
+    return '"' .. obj:gsub("\\", "\\\\"):gsub('"', '\\"') .. '"'
+  elseif type(obj) == "number" or type(obj) == "boolean" then
+    return tostring(obj)
+  elseif obj == nil then
+    return "null"
+  end
+end
+
+function scanner.execute_command(cmd)
+  local handle = io.popen(cmd .. " 2>&1")
+  if handle == nil then
+    return false, -1, ""
+  end
+  local result = handle:read("*a")
+  if result == nil then
+    result = ""
+  end
+  local success, exit_type, exit_code = handle:close()
+  -- io.popen's close() returns: true on success, or nil, "exit", code on failure
+  if success == nil then
+    return false, exit_code or -1, result
+  end
+  return true, 0, result
+end
+
+function scanner.file_exists(path)
+  local file = io.open(path, "r")
+  if file then
+    file:close()
+    return true
+  else
+    return false
+  end
+end
+
+function scanner.split_path(path_env)
+  local paths = {}
+  local sep = package.config:sub(1, 1) == "\\" and ";" or ":"
+  for path in string.gmatch(path_env, "([^" .. sep .. "]+)") do
+    table.insert(paths, path)
+  end
+  return paths
+end
+
+function scanner.get_gcc_version(gcc_path)
+  local success, exit_code, output = scanner.execute_command('"' .. gcc_path .. '" --version')
+  if output == nil then
+    return nil
+  end
+  -- Try multiple patterns to match different gcc output formats
+  local version = output:match("gcc%s+%(GCC%)%s+([%d%.]+)") -- "gcc (GCC) 15.2.1"
+    or output:match("gcc version ([%d%.]+)") -- "gcc version 11.4.0"
+  return version
+end
+
+function scanner.get_clang_version(clang_path)
+  local success, exit_code, output = scanner.execute_command('"' .. clang_path .. '" --version ')
+  if output == nil then
+    return nil
+  end
+  local version_line = output:match("clang version ([%d%.]+)")
+  return version_line
+end
+
+function scanner.find_compiler_pair(dir, c_compiler)
+  local base_name = c_compiler:match("([^/\\]+)$")
+  local cxx_name
+  if base_name:match("gcc") then
+    cxx_name = base_name:gsub("gcc", "g++")
+  elseif base_name:match("clang") then
+    cxx_name = base_name:gsub("clang", "clang++")
+  else
+    return nil
+  end
+  local cxx_path = dir .. "/" .. cxx_name
+  if scanner.file_exists(cxx_path) then
+    return cxx_path
+  end
+  return nil
+end
+
+function scanner.find_linker_pair(dir, linker_name)
+  if not linker_name then
+    return nil
+  end
+  local linker_path = dir .. "/" .. linker_name
+  if scanner.file_exists(linker_path) then
+    return linker_path
+  end
+  return nil
+end
+
+function scanner.get_toolchain_file()
+  local toolchainFile = os.getenv("CMAKE_TOOLCHAIN_FILE")
+  if toolchainFile and scanner.file_exists(toolchainFile) then
+    return toolchainFile
+  end
+  return nil
+end
+
+function scanner.ensure_directory(path)
+  local pattern = "(.*/)"
+  local dir = path:match(pattern)
+  if dir then
+    os.execute('mkdir -p "' .. dir .. '"')
+  end
+end
+
+function scanner.save_kits(kits, filepath)
+  scanner.ensure_directory(filepath)
+  local file = io.open(filepath, "w")
+  if not file then
+    error("Failed to open file for writing: " .. filepath)
+    return false
+  end
+  local json_content = scanner.json_encode(kits)
+  file:write(json_content)
+  file:close()
+  return true
+end
+
+-- Main fucntion to scan for kits
+function scanner.scan_for_kits()
+  local kits = {}
+
+  local path_env = os.getenv("PATH") or ""
+  local paths = scanner.split_path(path_env)
+
+  for _, dir in ipairs(paths) do
+    local linker_path = scanner.find_linker_pair(dir, "lld")
+    if linker_path == nil then
+      linker_path = scanner.find_linker_pair(dir, "ld")
+    end
+    local toolchainFile = scanner.get_toolchain_file()
+    local gcc_path = dir .. "/gcc"
+    if scanner.file_exists(gcc_path) then
+      local gcc_version = scanner.get_gcc_version(gcc_path)
+      local gxx_path = scanner.find_compiler_pair(dir, gcc_path)
+      if gxx_path then
+        local kit = {
+          name = "GCC-" .. (gcc_version or "unknown"),
+          compilers = {
+            C = gcc_path,
+            CXX = gxx_path,
+          },
+          linker = (linker_path or ""),
+          toolchainFile = (toolchainFile or ""),
+        }
+        table.insert(kits, kit)
+      end
+    end
+
+    local clang_path = dir .. "/clang"
+    if scanner.file_exists(clang_path) then
+      local clang_version = scanner.get_clang_version(clang_path)
+      local clangxx_path = scanner.find_compiler_pair(dir, clang_path)
+      if clangxx_path then
+        local kit = {
+          name = "Clang-" .. (clang_version or "unknown"),
+          compilers = {
+            C = clang_path,
+            CXX = clangxx_path,
+          },
+          linker = (linker_path or ""),
+          toolchainFile = (toolchainFile or ""),
+        }
+        table.insert(kits, kit)
+      end
+    end
+  end
+
+  if #kits == 0 then
+    print("No compilers found in PATH.")
+    return {}
+  end
+  scanner.save_kits(kits, scanner.KITS_FILE)
+  return kits
+end
+
+return scanner

lua/cmake-tools/types.lua

@@ -18,6 +18,7 @@ local Types = {
   "ANOTHER_JOB_RUNNING",
   "CMAKE_RUN_FAILED",
   "SETTINGS_ALREADY_OPENED",
+  "CANNOT_FIND_CMAKE_KITS",
 }
 
 Types[0] = "SUCCESS"

plugin/cmake-tools.lua

@@ -186,6 +186,15 @@ vim.api.nvim_create_user_command(
     desc = "CMake select cmake kit",
   }
 )
+--- CMake scan for kits
+vim.api.nvim_create_user_command(
+  "CMakeScanForKits", -- name
+  cmake_tools.scan_for_kits, -- command
+  { -- opts
+    nargs = 0,
+    desc = "CMake scan for cmake kits",
+  }
+)
 
 --- CMake select configure preset
 vim.api.nvim_create_user_command(