Terminal, Git et recherche globale intégrés dans Neovim

Ne plus quitter Neovim

Quatre outils transforment Neovim en cockpit de développement complet : toggleterm pour un terminal intégré, lazygit pour Git, grug-far pour les recherches-remplacements massives, trouble.nvim pour les diagnostics.

Terminal intégré avec Toggleterm

Un `Ctrl-`` fait apparaître un terminal horizontal en bas : pas de fenêtre qui se chevauche, juste un terminal qui popup et popdown.

{
  "akinsho/toggleterm.nvim",
  version = "*",
  opts = {
    size = 15,
    open_mapping = [[<c-`>]],
    hide_numbers = true,
    shade_terminals = true,
    shading_factor = 2,
    start_in_insert = true,
    persist_size = true,
    direction = "horizontal",
  },
}

Trois qualités qui comptent :

• Persistance : lancer bun dev, fermer le terminal, éditer du code, le rouvrir — le serveur tourne toujours.
• Shading visuel : le terminal est assombri par rapport au code, la distinction est immédiate.
• Plusieurs terminaux : chacun avec sa session, sa pwd et ses processus en cours.

Lancer un build, exécuter les tests, démarrer un serveur dev : plus aucune raison de quitter l'éditeur, et jamais de perte de contexte.

Git visuel avec Lazygit

Pour certaines opérations — rebase interactif, résolution de conflits, cherry-pick — un TUI est bien plus efficace que la ligne de commande. Lazygit s'intègre dans Neovim via toggleterm :

-- Lazygit comme terminal flottant
local Terminal = require("toggleterm.terminal").Terminal
local lazygit = Terminal:new({
  cmd = "lazygit",
  dir = "git_dir",
  direction = "float",
  float_opts = {
    border = "rounded",
  },
  on_open = function(term)
    vim.cmd("startinsert!")
  end,
  on_close = function(_)
    vim.cmd("startinsert!")
  end,
})

-- Keymap : <leader>gg pour ouvrir lazygit
vim.keymap.set("n", "<leader>gg", function()
  lazygit:toggle()
end, { desc = "Lazygit" })

Un <leader>gg ouvre une fenêtre flottante : staging fichier par fichier ou hunk par hunk, commit, push, pull, rebase interactif, stash, diffs visuels.

Ce qu'apporte le TUI face au git en ligne de commande :

• Diff visuel : on voit ligne par ligne ce qu'on stage, donc pas de surprise au commit.
• Rebase interactif : réordonner, squasher ou éditer des commits se fait aux flèches.
• Résolution de conflits : vue côte à côte, on choisit une version ou l'autre sans fusion manuelle de texte.

Recherche-remplacement globale avec Grug-far

Renommer une variable dans tout le projet, corriger un pattern récurrent, migrer une API : grug-far, propulsé par ripgrep, couvre ces cas.

{
  "MagicDuck/grug-far.nvim",
  opts = {
    headerMaxWidth = 80,
  },
  cmd = "GrugFar",
  keys = {
    {
      "<leader>S",
      function()
        local grug = require("grug-far")
        local ext = vim.bo.buftype == "" and vim.fn.expand("%:e")
        grug.open({
          transient = true,
          prefills = {
            filesFilter = ext and ext ~= "" and "*." .. ext or nil,
          },
        })
      end,
      mode = { "n", "v" },
      desc = "Search and Replace",
    },
    {
      "<leader>sw",
      function()
        local grug = require("grug-far")
        grug.open({
          transient = true,
          prefills = {
            search = vim.fn.expand("<cword>"),
          },
        })
      end,
      desc = "Search word under cursor",
    },
  },
}

<leader>S ouvre le panneau de recherche en split vertical, pré-filtré sur l'extension du fichier courant ; <leader>sw cherche directement le mot sous le curseur.

Ce qui distingue grug-far d'un simple sed : la prévisualisation en temps réel des remplacements, la revue fichier par fichier avec acceptation ou refus individuel, la puissance complète des regex ripgrep, et des patterns d'exclusion centralisés (node_modules, .git, .next, dist, lock files, minifiés).

Navigation dans les diagnostics avec Trouble.nvim

Trouble.nvim agrège tous les diagnostics du projet dans une liste navigable :

{
  "folke/trouble.nvim",
  opts = {
    use_diagnostic_signs = true,
  },
  cmd = "Trouble",
  keys = {
    { "<leader>xx", "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)" },
    { "<leader>xX", "<cmd>Trouble diagnostics toggle filter.buf=0<cr>", desc = "Buffer diagnostics" },
    { "<leader>xq", "<cmd>Trouble qflist toggle<cr>", desc = "Quickfix list (Trouble)" },
    { "<leader>xl", "<cmd>Trouble loclist toggle<cr>", desc = "Location list (Trouble)" },
  },
}

• <leader>xx : tous les diagnostics du projet — erreurs, warnings, hints.
• <leader>xX : filtre sur le fichier courant, utile quand on corrige un fichier précis.
• <leader>xq et <leader>xl : quickfix et location list dans Trouble, bien plus lisibles que les versions natives de Vim.

L'intégration LSP est transparente : erreurs TypeScript, warnings ESLint, diagnostics Python s'affichent tous et se parcourent aux touches normales.

Le workflow au quotidien

1. Éditer du code — buffer principal, navigation entre fenêtres (C-h, C-j, C-k, C-l) et entre buffers (S-h, S-l)
2. Vérifier les diagnostics — <leader>xx pour s'assurer que ça compile et que le linting passe
3. Refactoring massif — <leader>S pour ouvrir grug-far, faire le remplacement, valider
4. Commiter — <leader>gg pour lazygit : staging, message, push
5. Lancer les tests — `Ctrl-`` pour le terminal intégré

Zéro souris, et sauvegarder (<leader>w) puis quitter (<leader>q) complètent un workflow 100 % clavier.

Bilan

Quatre plugins qui transforment Neovim d'un éditeur de texte en environnement de développement complet : terminal intégré au lieu de fenêtres qui se chevauchent, Git rapide et visuel, refactoring à grande échelle sans stress, et tous les problèmes en une liste. Une fois en mémoire musculaire, le gain de temps par session est net.