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

Ne plus jamais quitter Neovim (enfin, presque)

Un éditeur c'est cool. Mais un environnement complet où vous pouvez éditer, chercher, commiter, exécuter des commandes, tout ça sans toucher à la souris? C'est un vrai rêve. Dans ma config Neovim (genre 1800 lignes de Lua, 46 plugins dont la moitié inutile), quatre outils transforment Neovim en véritable cockpit de développement. toggleterm pour un terminal intégré. lazygit pour Git. grug-far pour les recherches-remplacements massives. trouble.nvim pour les diagnostics. Avec ça, je quitte Neovim... jamais.

Terminal intégré avec Toggleterm (Ctrl+` et c'est parti)

Le réflexe naturel en terminaling? Ouvrir un second terminal. Avec toggleterm, c'est naturel : un coup de `Ctrl-`` et un terminal horizontal apparaît en bas. Pas de fenêtre qui se chevauche, pas de chaos. Juste un terminal qui popup/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",
  },
}

Pourquoi toggleterm est utile:

• Persistance : Vous lancez bun dev, vous fermez le terminal (Ctrl+`), vous éditez du code quelques minutes, vous le rouvrez? Le serveur tourne toujours. Pas de redémarrage chiant.
• Shading visuel : Le terminal est assombri par rapport au code. Vous voyez instantanément ce qui est terminal et ce qui est code.
• Plusieurs terminaux : Besoin de deux terminaux? Ouvrez-en deux. Chacun sa session, sa pwd, ses trucs en cours.

Tout ça pour dire: lancer un build, exécuter les tests, démarrer un serveur dev - zéro raison de quitter Neovim. Vous perdez jamais le contexte.

Git visuel avec Lazygit

J'utilise Git en ligne de commande depuis des années, mais pour certaines opérations -- rebase interactif, résolution de conflits, cherry-pick -- un TUI (Terminal User Interface) est infiniment plus efficace. Lazygit est ce TUI, et il s'intègre parfaitement 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 et une fenêtre flottante avec lazygit: staging fichier par fichier ou hunk par hunk, commit, push, pull, rebase interactif, stash, diffs visuels. Tout ce qu'on fait normalement avec 10 commandes git en ligne? Ici, c'est juste des flèches et entrée.

Pourquoi lazygit plutôt que du git bash brut?

• Diff visuel : Vous voyez ligne par ligne ce que vous stagez. Pas de surprise au commit.
• Rebase interactif : Réordonner des commits, les squasher, en éditer un - c'est juste des flèches et entrée.
• Résolution de conflits : Vue côte à côte. Vous choisissez une version ou l'autre. Pas de fusion manuelle de texte.

Recherche-remplacement globale avec Grug-far (refactoring à grande échelle)

Renommer une variable partout dans le projet? Corriger un pattern qui revient 100 fois? Migrer une API vers une autre? Vous avez besoin d'un outil de recherche-remplacement vraiment puissant. Grug-far, propulsé par ripgrep, c'est l'outil qu'il faut.

{
  "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",
    },
  },
}

Les raccourcis:

• <leader>S : Ouvre le panneau de recherche. Split vertical à gauche, pré-filtré sur l'extension du fichier courant. Pratique.
• <leader>sw : Cherche le mot sous le curseur directement.

Ce qui distingue grug-far d'un simple sed:

• Prévisualisation en temps réel : Vous voyez les remplacements avant de les appliquer. Pas de mauvaises surprises.
• Revue fichier par fichier : Vous pouvez accepter ou refuser chaque changement individuellement. Contrôle total.
• Regex complète : Toute la puissance de ripgrep. Pas de limitations bidon.
• Patterns d'exclusion : node_modules, .git, .next, dist, lock files, minifiés - tout ça est ignoré via une configuration centralisée. (ne me jugez pas d'avoir galéré sur ce truc pendant 1h)

Navigation dans les diagnostics avec Trouble.nvim (voir tous les problèmes d'un coup)

Le LSP remonte des erreurs et des warnings. Faut les parcourir. Trouble.nvim fournit un panneau dédié - vous voyez tous les diagnostics du projet en une seule 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)" },
  },
}

Les raccourcis que j'utilise:

• <leader>xx : Tous les diagnostics du projet. Erreurs, warnings, hints. Tout.
• <leader>xX : Filtre sur le fichier courant. Utile quand tu corriges un fichier spécifique et tu veux pas te disperser.
• <leader>xq : Quickfix list dans Trouble. Beaucoup plus lisible que le quickfix natif de Vim.
• <leader>xl : Location list. Même concept.

L'intégration LSP? Transparent. Chaque erreur TypeScript, chaque warning ESLint, chaque diagnostic Python s'affiche. Navigable avec les touches normales de Neovim.

Le workflow au quotidien (comment ça se passe vraiment)

Une session typique:

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, vous stagez, vous écrivez le message, vous pushez. Simple.
5. Lancer les tests - `Ctrl-`` pour le terminal intégré

Zéro souris. Des raccourcis logiques. Vous quittez jamais Neovim. Sauvegarder (<leader>w) et quitter (<leader>q) complètent le setup pour un workflow 100% clavier.

Voilà

Quatre plugins qui transforment Neovim d'un éditeur de texte en environnement de développement complet. Terminal intégré = plus de fenêtres qui se chevauchent. Lazygit = Git devient rapide et visuel. Grug-far = refactoring à grande échelle sans stress. Trouble = tous les problèmes en une liste. Une fois que c'est en mémoire musculaire, vous gagnez beaucoup de temps par session.