nvim + tmux：我的终端开发环境

init.lua              # 设置 leader，按顺序加载下面的模块
lazy-lock.json        # 插件版本锁定，换机器时装出同一套版本
lua/config/
  options.lua         # 编辑器选项
  autocmds.lua        # 自动命令：复制高亮、按语言设缩进
  keymaps.lua         # 全局快捷键
  lazy.lua            # 安装并启动 lazy.nvim
  lsp.lua             # LSP：用 nvim 0.11 自带的 vim.lsp.config
lua/plugins/
  editor.lua          # 主题、文件浏览、状态栏、git 标记
  lsp.lua             # 补全、代码片段、格式化
  search.lua          # 模糊搜索、语法树、lazygit

tmux ~
- ✅ OK escape-time: 10
- ✅ OK focus-events: on
- $TERM: screen-256color

set -g default-terminal "screen-256color"
set -as terminal-features ",xterm-256color:RGB"   # 外层终端是 xterm-256color 时，告诉 tmux 它支持真彩色
set -sg escape-time 10                            # 收到 Esc 后只等 10ms，判断是不是转义序列
set -g focus-events on                            # 把「切回这个 pane」的焦点事件转发给 nvim

#!/usr/bin/env bash
S=myapp
DIR=~/code/myapp

# 会话已存在就直接进入
tmux has-session -t "$S" 2>/dev/null && exec tmux attach -t "$S"

tmux new-session -d -s "$S" -n code -c "$DIR"                 # 窗口 1：code
tmux send-keys -t "$S:code.1" 'nvim .' Enter                  # 左边 pane 开 nvim
tmux split-window -h -t "$S:code" -c "$DIR" -l 35%            # 右边 35% 宽的 pane
tmux send-keys -t "$S:code.2" 'pnpm dev' Enter                # 在右边启动服务
tmux new-window -t "$S" -n git -c "$DIR"                      # 窗口 2：git
tmux send-keys -t "$S:git" 'lazygit' Enter
tmux select-window -t "$S:code"
tmux select-pane -t "$S:code.1"
exec tmux attach -t "$S"

vim.g.mapleader = " "
vim.g.maplocalleader = " "

require("config.options")
require("config.autocmds")
require("config.keymaps")
require("config.lazy")
require("config.lsp")

local opt = vim.opt
local home = vim.fn.expand("$HOME")

vim.env.PATH = table.concat({
  home .. "/go/bin",
  home .. "/.nvm/versions/prefix/bin",
  home .. "/.bun/bin",
  vim.env.PATH or "",
}, ":")

opt.number = true
opt.relativenumber = true
opt.mouse = "a"
opt.clipboard = "unnamedplus"
opt.termguicolors = true
opt.signcolumn = "yes"
opt.updatetime = 250
opt.timeoutlen = 300
opt.splitright = true
opt.splitbelow = true
opt.ignorecase = true
opt.smartcase = true
opt.cursorline = true
opt.scrolloff = 8
opt.sidescrolloff = 8
opt.wrap = false
opt.completeopt = { "menu", "menuone", "noselect" }

opt.expandtab = true
opt.shiftwidth = 2
opt.tabstop = 2
opt.softtabstop = 2
opt.smartindent = true

local group = vim.api.nvim_create_augroup("local_config", { clear = true })

vim.api.nvim_create_autocmd("TextYankPost", {
  group = group,
  callback = function()
    vim.highlight.on_yank()
  end,
})

vim.api.nvim_create_autocmd("FileType", {
  group = group,
  pattern = { "go" },
  callback = function()
    vim.opt_local.expandtab = false
    vim.opt_local.shiftwidth = 4
    vim.opt_local.tabstop = 4
    vim.opt_local.softtabstop = 4
  end,
})

vim.api.nvim_create_autocmd("FileType", {
  group = group,
  pattern = { "rust" },
  callback = function()
    vim.opt_local.shiftwidth = 4
    vim.opt_local.tabstop = 4
    vim.opt_local.softtabstop = 4
  end,
})

local map = vim.keymap.set

map("n", "<leader>w", "<cmd>w<cr>", { desc = "Write file" })
map("n", "<leader>q", "<cmd>q<cr>", { desc = "Quit window" })
map("n", "<leader>e", "<cmd>Oil<cr>", { desc = "Open file browser" })
map("n", "<leader>ff", "<cmd>Telescope find_files<cr>", { desc = "Find files" })
map("n", "<leader>fg", "<cmd>Telescope live_grep<cr>", { desc = "Live grep" })
map("n", "<leader>fb", "<cmd>Telescope buffers<cr>", { desc = "Buffers" })
map("n", "<leader>fh", "<cmd>Telescope help_tags<cr>", { desc = "Help tags" })
map("n", "<leader>gg", "<cmd>LazyGit<cr>", { desc = "LazyGit" })
map("n", "-", "<cmd>Oil<cr>", { desc = "Open parent directory" })
map("n", "<Esc>", "<cmd>nohlsearch<cr>", { desc = "Clear search highlight" })

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"

if not vim.uv.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end

vim.opt.rtp:prepend(lazypath)

require("lazy").setup("plugins", {
  change_detection = { notify = false },
  install = { colorscheme = { "tokyonight", "habamax" } },
  ui = { border = "rounded" },
})

local capabilities = vim.lsp.protocol.make_client_capabilities()

local cmp_ok, cmp_lsp = pcall(require, "cmp_nvim_lsp")
if cmp_ok then
  capabilities = cmp_lsp.default_capabilities(capabilities)
end

local on_attach = function(_, bufnr)
  local map = function(mode, lhs, rhs, desc)
    vim.keymap.set(mode, lhs, rhs, { buffer = bufnr, desc = desc })
  end

  map("n", "gd", vim.lsp.buf.definition, "Go to definition")
  map("n", "gr", vim.lsp.buf.references, "References")
  map("n", "gi", vim.lsp.buf.implementation, "Implementation")
  map("n", "K", vim.lsp.buf.hover, "Hover")
  map("n", "<leader>rn", vim.lsp.buf.rename, "Rename symbol")
  map("n", "<leader>ca", vim.lsp.buf.code_action, "Code action")
  map("n", "<leader>f", function()
    require("conform").format({ async = false, lsp_fallback = true })
  end, "Format buffer")
end

local servers = {
  gopls = {
    cmd = { "gopls" },
    filetypes = { "go", "gomod", "gowork", "gotmpl" },
    root_markers = { "go.work", "go.mod", ".git" },
  },
  rust_analyzer = {
    cmd = { "rust-analyzer" },
    filetypes = { "rust" },
    root_markers = { "Cargo.toml", ".git" },
  },
  ts_ls = {
    cmd = { "typescript-language-server", "--stdio" },
    filetypes = { "javascript", "javascriptreact", "typescript", "typescriptreact" },
    root_markers = { "package.json", "tsconfig.json", "jsconfig.json", ".git" },
  },
}

for name, config in pairs(servers) do
  local executable = config.cmd[1]
  if vim.fn.executable(executable) == 1 and vim.lsp.config and vim.lsp.enable then
    config.capabilities = capabilities
    config.on_attach = on_attach
    vim.lsp.config(name, config)
    vim.lsp.enable(name)
  end
end

return {
  {
    "folke/tokyonight.nvim",
    lazy = false,
    priority = 1000,
    config = function()
      vim.cmd.colorscheme("tokyonight-night")
    end,
  },
  {
    "stevearc/oil.nvim",
    dependencies = { "nvim-tree/nvim-web-devicons" },
    opts = {
      default_file_explorer = true,
      view_options = { show_hidden = true },
    },
  },
  {
    "nvim-lualine/lualine.nvim",
    dependencies = { "nvim-tree/nvim-web-devicons" },
    opts = {
      options = {
        theme = "tokyonight",
        globalstatus = true,
      },
    },
  },
  {
    "lewis6991/gitsigns.nvim",
    opts = {},
  },
}

return {
  {
    "neovim/nvim-lspconfig",
  },
  {
    "hrsh7th/nvim-cmp",
    dependencies = {
      "hrsh7th/cmp-nvim-lsp",
      "L3MON4D3/LuaSnip",
      "saadparwaiz1/cmp_luasnip",
      "rafamadriz/friendly-snippets",
    },
    config = function()
      local cmp = require("cmp")
      local luasnip = require("luasnip")

      require("luasnip.loaders.from_vscode").lazy_load()

      cmp.setup({
        snippet = {
          expand = function(args)
            luasnip.lsp_expand(args.body)
          end,
        },
        mapping = cmp.mapping.preset.insert({
          ["<C-Space>"] = cmp.mapping.complete(),
          ["<CR>"] = cmp.mapping.confirm({ select = true }),
          ["<Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_next_item()
            elseif luasnip.expand_or_jumpable() then
              luasnip.expand_or_jump()
            else
              fallback()
            end
          end, { "i", "s" }),
          ["<S-Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then
              luasnip.jump(-1)
            else
              fallback()
            end
          end, { "i", "s" }),
        }),
        sources = cmp.config.sources({
          { name = "nvim_lsp" },
          { name = "luasnip" },
        }),
      })
    end,
  },
  {
    "stevearc/conform.nvim",
    opts = {
      formatters_by_ft = {
        go = { "goimports", "gofmt" },
        javascript = { "prettierd", "prettier" },
        javascriptreact = { "prettierd", "prettier" },
        typescript = { "prettierd", "prettier" },
        typescriptreact = { "prettierd", "prettier" },
        json = { "prettierd", "prettier" },
        jsonc = { "prettierd", "prettier" },
        markdown = { "prettierd", "prettier" },
        rust = { "rustfmt" },
        yaml = { "prettierd", "prettier" },
      },
      format_on_save = {
        timeout_ms = 800,
        lsp_fallback = true,
      },
    },
  },
}

return {
  {
    "nvim-lua/plenary.nvim",
    lazy = true,
  },
  {
    "nvim-telescope/telescope.nvim",
    dependencies = { "nvim-lua/plenary.nvim" },
    config = function()
      require("telescope").setup({
        defaults = {
          layout_strategy = "horizontal",
          sorting_strategy = "ascending",
          layout_config = {
            prompt_position = "top",
          },
        },
      })
    end,
  },
  {
    "nvim-treesitter/nvim-treesitter",
    lazy = false,
    build = ":TSUpdate",
    config = function()
      local ok, treesitter = pcall(require, "nvim-treesitter")
      if not ok then
        return
      end

      treesitter.setup({
        install_dir = vim.fn.stdpath("data") .. "/site",
      })

      vim.api.nvim_create_autocmd("FileType", {
        pattern = {
          "bash",
          "go",
          "javascript",
          "json",
          "lua",
          "markdown",
          "rust",
          "toml",
          "tsx",
          "typescript",
          "yaml",
        },
        callback = function(args)
          pcall(vim.treesitter.start, args.buf)
        end,
      })
    end,
  },
  {
    "kdheepak/lazygit.nvim",
    cmd = {
      "LazyGit",
      "LazyGitConfig",
      "LazyGitCurrentFile",
      "LazyGitFilter",
      "LazyGitFilterCurrentFile",
    },
    dependencies = { "nvim-lua/plenary.nvim" },
  },
}