diff options
Diffstat (limited to 'common/config/nvim/lua/setup/manager.lua')
| -rwxr-xr-x | common/config/nvim/lua/setup/manager.lua | 811 |
1 files changed, 811 insertions, 0 deletions
diff --git a/common/config/nvim/lua/setup/manager.lua b/common/config/nvim/lua/setup/manager.lua new file mode 100755 index 0000000..9cf1d14 --- /dev/null +++ b/common/config/nvim/lua/setup/manager.lua @@ -0,0 +1,811 @@ +-- manager.lua + +local M = {} + +-- State tracking +local state = { + manager_invoked = nil, + initialized = false, + bootstrap_completed = {}, +} + +-- Path constants +local PATHS = { + lazy = vim.fn.stdpath("data") .. "/lazy/lazy.nvim", + packer = vim.fn.stdpath("data") .. "/site/pack/packer/start/packer.nvim", + packer_dir = vim.fn.stdpath("data") .. "/site/pack/packer/start", + builtin_dir = vim.fn.stdpath("data") .. "/nvim/site/pack/core/opt", +} + +-- Utility functions +local function safe_require(module) + local ok, result = pcall(require, module) + return ok and result or nil +end + +local function notify(msg, level) + vim.notify("[Manager] " .. msg, level or vim.log.levels.INFO) +end + +local function execute_git_command(cmd, _) + -- Use vim.fn.system instead of os.execute for better cross-platform support and error handling + local result = vim.fn.system(cmd) + return vim.v.shell_error == 0 +end + +local function get_nvim_version() + local version = vim.version() + if version then + return version.major, version.minor, version.patch + end + + -- Fallback for older versions + local version_str = vim.fn.execute("version"):match("NVIM v(%d+%.%d+%.%d+)") + if version_str then + local major, minor, patch = version_str:match("(%d+)%.(%d+)%.(%d+)") + return tonumber(major), tonumber(minor), tonumber(patch) + end + return 0, 0, 0 +end + +local function has_builtin_manager() + local major, minor = get_nvim_version() + return major > 0 or (major == 0 and minor >= 12) +end + +-- CRITICAL FIX: This function is essential to prevent runtime conflicts. +-- It removes the specified manager's directory from the runtimepath. +local function cleanup_manager(manager_name) + if manager_name == "packer" then + -- Reset packer state and remove from rtp + local packer = safe_require("packer") + if packer then + pcall(packer.reset) + end + -- Remove the entire packer directory from rtp + local packer_rtp = vim.fn.glob(PATHS.packer_dir) + if packer_rtp then + local rtp_items = vim.split(vim.o.rtp, ",") + local new_rtp_items = {} + for _, item in ipairs(rtp_items) do + if item ~= packer_rtp then + table.insert(new_rtp_items, item) + end + end + vim.o.rtp = table.concat(new_rtp_items, ",") + end + elseif manager_name == "lazy" then + -- Lazy.nvim clears its state on each run, but we can remove it from rtp for good measure + local lazy_rtp = vim.fn.glob(PATHS.lazy) + if lazy_rtp then + local rtp_items = vim.split(vim.o.rtp, ",") + local new_rtp_items = {} + for _, item in ipairs(rtp_items) do + if item ~= lazy_rtp then + table.insert(new_rtp_items, item) + end + end + vim.o.rtp = table.concat(new_rtp_items, ",") + end + elseif manager_name == "builtin" then + -- Built-in manager is handled by vim.opt.packpath and doesn't need manual cleanup from rtp + -- unless we want to disable its packages, which isn't the goal here. + end +end + +-- IMPROVED: Use vim.g for persistence instead of file system +local function save_manager_choice(manager_name) + vim.g.nvim_manager_choice = manager_name + -- Also save to data directory as a simple text file for true persistence across sessions + local data_dir = vim.fn.stdpath("data") + local choice_file = data_dir .. "/.manager_choice" + local file = io.open(choice_file, "w") + if file then + file:write(manager_name) + file:close() + end +end + +local function load_manager_choice() + -- First check vim.g (current session) + if vim.g.nvim_manager_choice then + return vim.g.nvim_manager_choice + end + + -- Then check persistent file + local data_dir = vim.fn.stdpath("data") + local choice_file = data_dir .. "/.manager_choice" + local file = io.open(choice_file, "r") + if file then + local choice = file:read("*a"):gsub("%s+", "") -- trim whitespace + file:close() + if choice and choice ~= "" then + vim.g.nvim_manager_choice = choice -- cache in session + return choice + end + end + + return nil +end + +--- Packer Manager Implementation +-- +-- Handles cloning, setup, and configuration of Packer.nvim. +local Packer = {} + +function Packer.bootstrap() + if state.bootstrap_completed.packer then + return true + end + + local fn = vim.fn + if fn.isdirectory(PATHS.packer_dir) == 0 then + fn.mkdir(PATHS.packer_dir, "p") + end + + if fn.empty(fn.glob(PATHS.packer)) > 0 then + local is_windows = vim.loop.os_uname().version:match("Windows") + local git_cmd + + if is_windows then + git_cmd = string.format( + 'git clone --depth=1 https://github.com/wbthomason/packer.nvim "%s" >nul 2>&1', + PATHS.packer + ) + else + git_cmd = string.format( + 'env -i PATH="%s" HOME="%s" git clone --depth=1 --quiet https://github.com/wbthomason/packer.nvim %q >/dev/null 2>&1', + os.getenv("PATH") or "/usr/bin:/bin", + os.getenv("HOME") or "/tmp", + PATHS.packer + ) + end + + if not execute_git_command(git_cmd, "Failed to clone packer.nvim") then + return false + end + end + + state.bootstrap_completed.packer = true + return true +end + +function Packer.setup() + if not Packer.bootstrap() then + return false + end + + -- Ensure packer.nvim is in the runtime path + vim.cmd("packadd packer.nvim") + + local packer = safe_require("packer") + if not packer then + notify("Failed to load packer.nvim", vim.log.levels.ERROR) + return false + end + + -- Reset any existing configuration from a previous run + pcall(packer.reset) + + packer.init({ + auto_reload_compiled = true, + display = { + open_fn = function() + return require("packer.util").float({ border = "rounded" }) + end, + }, + luarocks = { + python_cmd = 'python3' + }, + }) + + local plugins = safe_require("setup.plugins") + if not plugins then + notify("Failed to load plugins configuration", vim.log.levels.ERROR) + return false + end + + packer.startup(function(use) + use "wbthomason/packer.nvim" + for _, plugin in ipairs(plugins) do + -- CHECK FOR EXCLUDE HERE - Packer support for exclude option + if plugin.exclude and vim.tbl_contains(plugin.exclude, "packer") then + --notify("Excluding plugin for packer: " .. (plugin.name or plugin.as or plugin[1] or "unknown"), vim.log.levels.INFO) + goto continue + end + + -- Packer doesn't have a lazy option, so we ensure all plugins are loaded eagerly + -- by clearing any lazy-loading keys from the plugins table. + local packer_plugin = vim.deepcopy(plugin) + packer_plugin.event = nil + packer_plugin.keys = nil + packer_plugin.cmd = nil + packer_plugin.ft = nil + packer_plugin.lazy = nil + packer_plugin.exclude = nil -- Remove exclude from the actual plugin spec + use(packer_plugin) + ::continue:: + end + end) + + return true +end + +function Packer.is_available() + return vim.fn.isdirectory(PATHS.packer) == 1 +end + +--- Lazy.nvim Manager Implementation +-- +local Lazy = {} + +function Lazy.bootstrap() + if state.bootstrap_completed.lazy then + return true + end + + -- Check if lazy.nvim is already cloned + if not vim.loop.fs_stat(PATHS.lazy) then + local is_windows = vim.loop.os_uname().version:match("Windows") + local git_cmd + + if is_windows then + git_cmd = string.format( + 'git clone --filter=blob:none --branch=stable https://github.com/folke/lazy.nvim.git "%s" >nul 2>&1', + PATHS.lazy + ) + else + git_cmd = string.format( + 'env -i PATH="%s" HOME="%s" git clone --filter=blob:none --branch=stable --quiet https://github.com/folke/lazy.nvim.git %q >/dev/null 2>&1', + os.getenv("PATH") or "/usr/bin:/bin", + os.getenv("HOME") or "/tmp", + PATHS.lazy + ) + end + + if not execute_git_command(git_cmd, "Failed to clone lazy.nvim") then + return false + end + end + + state.bootstrap_completed.lazy = true + return true +end + +function Lazy.setup() + if not Lazy.bootstrap() then + return false + end + + -- Ensure lazy.nvim is in the runtime path before requiring it + vim.opt.rtp:prepend(PATHS.lazy) + + local lazy = safe_require("lazy") + if not lazy then + notify("Failed to load lazy.nvim", vim.log.levels.ERROR) + return false + end + + -- FIX: Correctly require plugins and set up lazy.nvim + local plugins = safe_require("setup.plugins") + if not plugins then + notify("Failed to load plugins configuration", vim.log.levels.ERROR) + return false + end + + -- Filter out excluded plugins for Lazy + local filtered_plugins = {} + for _, plugin in ipairs(plugins) do + -- CHECK FOR EXCLUDE HERE - Lazy support for exclude option + if plugin.exclude and vim.tbl_contains(plugin.exclude, "lazy") then + --notify("Excluding plugin for lazy: " .. (plugin.name or plugin[1] or "unknown"), vim.log.levels.INFO) + else + local lazy_plugin = vim.deepcopy(plugin) + lazy_plugin.exclude = nil -- Remove exclude from the actual plugin spec + table.insert(filtered_plugins, lazy_plugin) + end + end + + -- Setup Lazy.nvim with the correct options + lazy.setup(filtered_plugins, { + { + import = "plugins", + }, + defaults = { lazy = false }, -- Set plugins to be lazy-loaded by default + install = { missing = true }, -- CRITICAL FIX: This ensures missing plugins are installed + ui = { + border = "rounded", + }, + performance = { + rtp = { + disabled_plugins = { + "gzip", "matchit", "matchparen", "netrwPlugin", + "tarPlugin", "tohtml", "tutor", "zipPlugin", + }, + }, + }, + }) + + return true +end + +function Lazy.is_available() + return vim.loop.fs_stat(PATHS.lazy) ~= nil +end + +--- Built-in manager implementation (Neovim 0.12+) +-- +local Builtin = {} + +function Builtin.bootstrap() + if not has_builtin_manager() then + --notify("Built-in package manager not available in this Neovim version", vim.log.levels.WARN) + return false + end + + state.bootstrap_completed.builtin = true + return true +end + +function Builtin.setup() + if not has_builtin_manager() then + --notify("Built-in package manager not available in this Neovim version", vim.log.levels.WARN) + return false + end + + local plugins = safe_require("setup.plugins") + if not plugins then + notify("Failed to load plugins configuration", vim.log.levels.ERROR) + return false + end + + -- Convert plugins to builtin manager format + local builtin_specs = {} + for _, plugin in ipairs(plugins) do + -- CHECK FOR EXCLUDE HERE + if plugin.exclude and vim.tbl_contains(plugin.exclude, "builtin") then + --notify("Excluding plugin for builtin: " .. (plugin.name or plugin[1] or "unknown"), vim.log.levels.INFO) + goto continue + end + local spec = {} + + if type(plugin) == "string" then + -- Handle string format like "user/repo" + if plugin:match("^[%w%-_%.]+/[%w%-_%.]+$") then + -- It's a GitHub shorthand + spec.src = "https://github.com/" .. plugin + spec.name = plugin:match("/([%w%-_%.]+)$") -- Extract repo name + else + -- It's already a full URL + spec.src = plugin + end + elseif type(plugin) == "table" then + -- Handle table format + if plugin[1] and type(plugin[1]) == "string" then + -- Format like {"user/repo", ...} + if plugin[1]:match("^[%w%-_%.]+/[%w%-_%.]+$") then + spec.src = "https://github.com/" .. plugin[1] + spec.name = plugin[1]:match("/([%w%-_%.]+)$") + else + spec.src = plugin[1] + end + + -- Copy other properties + for k, v in pairs(plugin) do + if type(k) == "string" then + spec[k] = v + end + end + elseif plugin.src then + spec.src = plugin.src + for k, v in pairs(plugin) do + if k ~= "src" then + spec[k] = v + end + end + elseif plugin.url then + spec.src = plugin.url + for k, v in pairs(plugin) do + if k ~= "url" then + spec[k] = v + end + end + else + notify("Invalid plugin specification for built-in manager: " .. vim.inspect(plugin), vim.log.levels.WARN) + goto continue + end + + -- Handle name override + if plugin.name then + spec.name = plugin.name + elseif plugin.as then + spec.name = plugin.as + elseif not spec.name and spec.src then + -- Extract name from URL if not specified + spec.name = spec.src:match("/([%w%-_%.]+)%.git$") or spec.src:match("/([%w%-_%.]+)$") or spec.src + end + + -- Handle version + if plugin.version then + spec.version = plugin.version + end + + -- Remove keys that builtin manager doesn't understand + spec.lazy = nil + spec.event = nil + spec.keys = nil + spec.cmd = nil + spec.ft = nil + spec.dependencies = nil + spec.config = nil + spec.build = nil + spec.run = nil + spec.priority = nil + spec.as = nil + spec.url = nil + spec.exclude = nil + spec[1] = nil -- Remove positional argument + end + + if spec.src then + table.insert(builtin_specs, spec) + end + ::continue:: + end + + -- Debug: Show what we're about to install + --notify(string.format("Installing %d plugins with built-in manager", #builtin_specs), vim.log.levels.INFO) + + -- CRITICAL FIX: Call vim.pack.add with the specs directly, not wrapped in array + if #builtin_specs > 0 then + local ok, err = pcall(vim.pack.add, builtin_specs) + if not ok then + notify("Failed to add plugins: " .. tostring(err), vim.log.levels.ERROR) + return false + end + + --notify("Plugins added successfully. Use :Pack to install/update them.", vim.log.levels.INFO) + else + notify("No valid plugins found for built-in manager", vim.log.levels.WARN) + end + + -- Create user commands for convenience - FIXED COMMAND NAMES + vim.api.nvim_create_user_command("Package", function(opts) + local subcommand = opts.fargs[1] or "update" + local names = vim.list_slice(opts.fargs, 2) + + if subcommand == "add" then + -- For add, we need to re-run setup to add new plugins + --notify("Re-running builtin manager setup to add new plugins...") + Builtin.setup() + elseif subcommand == "update" then + if #names == 0 then + names = nil -- Update all plugins + end + vim.pack.update(names) + elseif subcommand == "status" then + local plugins = vim.pack.get() + print(string.format("Built-in manager: %d plugins managed", #plugins)) + for _, plugin in ipairs(plugins) do + local status = plugin.active and "active" or "inactive" + print(string.format(" %s (%s): %s", plugin.spec.name, status, plugin.path)) + end + else + -- Default behavior - treat as update + if subcommand then + table.insert(names, 1, subcommand) + end + if #names == 0 then + names = nil + end + vim.pack.update(names) + end + end, { + nargs = "*", + complete = function(arglead, cmdline, cursorpos) + local args = vim.split(cmdline, "%s+") + if #args <= 2 then + -- Complete subcommands + local subcommands = { "add", "update", "status" } + local matches = {} + for _, cmd in ipairs(subcommands) do + if cmd:find("^" .. arglead) then + table.insert(matches, cmd) + end + end + return matches + else + -- Complete plugin names + local plugins = vim.pack.get() + local names = {} + for _, plugin in ipairs(plugins) do + if plugin.spec.name:find("^" .. arglead) then + table.insert(names, plugin.spec.name) + end + end + return names + end + end, + desc = "Manage plugins with built-in manager. Usage: :Pack [add|update|status] [plugin_names...]" + }) + + ---- Keep the old command for backwards compatibility + --vim.api.nvim_create_user_command("PackageStatus", function() + -- vim.cmd("Pack status") + --end, { + -- nargs = 0, + -- desc = "Show status of plugins managed by built-in manager (deprecated, use :Pack status)" + --}) + + return true +end + +function Builtin.is_available() + return has_builtin_manager() +end + +--- Manager registry +-- +local MANAGERS = { + packer = Packer, + lazy = Lazy, + builtin = Builtin, +} + +--- Core management functions +-- +local function activate_manager(manager_name) + local manager = MANAGERS[manager_name] + if not manager then + notify("Unknown manager: " .. manager_name, vim.log.levels.ERROR) + return false + end + + -- Cleanup the old manager before activating the new one to prevent runtime conflicts. + if state.manager_invoked and state.manager_invoked ~= manager_name then + cleanup_manager(state.manager_invoked) + end + + if not manager.bootstrap() then + return false + end + + local ok = manager.setup() + if ok then + state.manager_invoked = manager_name + -- CRITICAL FIX: Persist the manager choice after successful setup + save_manager_choice(manager_name) + end + return ok +end + +--- Auto-detection and command setup +-- +local function setup_auto_detection() + -- Autocmd to activate Packer when Packer commands are used + vim.api.nvim_create_autocmd("CmdUndefined", { + pattern = "Packer*", + callback = function(event) + if state.manager_invoked ~= "packer" then + local ok = activate_manager("packer") + if ok then + -- Re-execute the original command after setup + vim.cmd(event.match) + end + end + end, + desc = "Auto-activate Packer when Packer commands are used" + }) + + -- Autocmd to activate Lazy when Lazy commands are used + vim.api.nvim_create_autocmd("CmdUndefined", { + pattern = "Lazy*", + callback = function(event) + if state.manager_invoked ~= "lazy" then + local ok = activate_manager("lazy") + if ok then + -- CRITICAL FIX: Use vim.schedule to defer the command execution + -- This ensures Lazy's setup is complete before running the command. + vim.schedule(function() + pcall(vim.cmd, event.match) + end) + end + end + end, + desc = "Auto-activate Lazy and re-execute command" + }) + + vim.api.nvim_create_autocmd("CmdUndefined", { + pattern = "Package*", + callback = function(event) + if state.manager_invoked ~= "builtin" and has_builtin_manager() then + local ok = activate_manager("builtin") + if ok then + vim.cmd(event.match) + end + end + end, + desc = "Auto-activate built-in manager when Pack commands are used" + }) +end + +--- Public API +-- +function M.setup() + if state.initialized then + return + end + + -- Initial bootstrap attempt for all managers to see what's available + for name, manager in pairs(MANAGERS) do + -- CRITICAL FIX: Always bootstrap, but don't set up yet + pcall(manager.bootstrap) + end + + -- CRITICAL FIX: Check for a previously saved choice + local persistent_choice = load_manager_choice() + if persistent_choice and MANAGERS[persistent_choice] then + -- If a choice exists, immediately activate that manager for this session + activate_manager(persistent_choice) + else + -- If no choice exists, set up the autocmds to wait for a command + setup_auto_detection() + end + + state.initialized = true +end + +function M.use_manager(manager_name) + if not state.initialized then + M.setup() + end + + local available = M.available_managers() + if not vim.tbl_contains(available, manager_name) then + notify(string.format("Manager '%s' is not available. Available: %s", + manager_name, table.concat(available, ", ")), vim.log.levels.WARN) + return false + end + + return activate_manager(manager_name) +end + +function M.available_managers() + local managers = {} + for name, manager in pairs(MANAGERS) do + if manager.is_available() then + table.insert(managers, name) + end + end + return managers +end + +function M.current_manager() + return state.manager_invoked +end + +function M.status() + local info = { + initialized = state.initialized, + current_manager = state.manager_invoked, + available_managers = M.available_managers(), + bootstrap_completed = state.bootstrap_completed, + } + + print("=== Neovim Plugin Manager Status ===") + print(string.format("Initialized: %s", tostring(info.initialized))) + print(string.format("Current Manager: %s", info.current_manager or "None")) + print(string.format("Available Managers: %s", table.concat(info.available_managers, ", "))) + + -- FIX: Properly format the Neovim version + local major, minor, patch = get_nvim_version() + print(string.format("Neovim Version: %d.%d.%d", major, minor, patch)) + print(string.format("Built-in Support: %s", tostring(has_builtin_manager()))) + + return info +end + +-- FIX: Added M.get_nvim_version function to the public API +function M.get_nvim_version() + local major, minor, patch = get_nvim_version() + return { major = major, minor = minor, patch = patch } +end + +function M.reset_nvim() + vim.ui.input({ + prompt = "Are you sure you want to reset Neovim? This will delete all data, state, cache, and plugins. (y/N): " + }, function(input) + if input and input:lower() == "y" then + local fn = vim.fn + local is_windows = vim.loop.os_uname().version:match("Windows") + + local paths_to_remove = { + fn.stdpath("data"), + fn.stdpath("state"), + fn.stdpath("cache"), + fn.stdpath("config") .. "/plugin", + } + + local cmd = "" + if is_windows then + local paths_quoted = {} + for _, path in ipairs(paths_to_remove) do + table.insert(paths_quoted, string.format('"%s"', path)) + end + cmd = "powershell -Command \"Remove-Item " .. + table.concat(paths_quoted, ", ") .. " -Recurse -Force -ErrorAction SilentlyContinue\"" + else + local paths_quoted = {} + for _, path in ipairs(paths_to_remove) do + table.insert(paths_quoted, vim.fn.shellescape(path)) + end + cmd = "rm -rf " .. table.concat(paths_quoted, " ") + end + + notify("Resetting Neovim... Please restart after this operation.") + + vim.defer_fn(function() + local result = os.execute(cmd) + if result ~= 0 then + notify("Reset command may have failed. You might need to delete directories manually.", vim.log.levels.WARN) + else + notify("Reset completed successfully. Please restart Neovim.") + end + end, 100) + else + notify("Reset cancelled.") + end + end) +end + +-- Clear manager choice function +function M.clear_choice() + vim.g.nvim_manager_choice = nil + local data_dir = vim.fn.stdpath("data") + local choice_file = data_dir .. "/.manager_choice" + os.remove(choice_file) + notify("Manager choice cleared. Next command will determine the manager.") +end + +vim.api.nvim_create_user_command("Reset", function() + M.reset_nvim() +end, { + nargs = 0, + desc = "Reset Neovim's data, state, cache, and plugin directories" +}) + +local function manager_command(opts) + local subcommand = opts.fargs[1] + + if subcommand == "status" then + M.status() + elseif subcommand == "packer" or subcommand == "Packer" then + M.use_manager("packer") + elseif subcommand == "lazy" or subcommand == "Lazy" then + M.use_manager("lazy") + elseif subcommand == "builtin" or subcommand == "built-in" or subcommand == "Builtin" or subcommand == "Built-in" then + M.use_manager("builtin") + elseif subcommand == "clear" then + M.clear_choice() + else + print("Unknown subcommand. Try 'status', 'packer', 'lazy', 'builtin' or 'clear'.") + end +end + +vim.api.nvim_create_user_command("Manager", manager_command, { + nargs = "+", + complete = function(arglead) + local subcommands = { "status", "packer", "Packer", "lazy", "Lazy", "builtin", "built-in", "Builtin", "Built-in", + "clear" } + local result = {} + for _, subcommand in ipairs(subcommands) do + if subcommand:find("^" .. arglead, 1) then + table.insert(result, subcommand) + end + end + return result + end, + desc = "Manage plugins. Subcommands: status, packer, lazy, builtin, clear" +}) + +return M |